lexer grammar nasm_x86_64_Lexer;

options { caseInsensitive=true; }


DB: 'db';
DW: 'dw';
DD: 'dd';
DQ: 'dq';
DT: 'dt';
DO: 'do';
DY: 'dy';
DZ: 'dz';
RESB: 'resb';
RESW: 'resw';
RESD: 'resd';
RESQ: 'resq';
REST: 'rest';
RESO: 'reso';
RESY: 'resy';
RESZ: 'resz';
INCBIN: 'incbin';

BYTE: 'byte';
WORD: 'word';
DWORD: 'dword';
QWORD: 'qword';
TWORD: 'tword';
OWORD: 'oword';
YWORD: 'yword';
ZWORD: 'zword';

DUP: 'dup';

COMMA: ',';
QUESTION: '?';
LEFT_PARENTHESIS: '(';
RIGHT_PARENTHESIS: ')';
LEFT_BRACKET: '[';
RIGHT_BRACKET: ']';
COLON: ':';
BOOLEAN_OR: '||';
BOOLEAN_XOR: '^^';
BOOLEAN_AND: '&&';
EQUAL_1: '=';
EQUAL_2: '==';
NOT_EQUAL_1: '!=';
NOT_EQUAL_2: '<>';
LESS_THAN: '<';
LESS_THAN_EQUAL: '<=';
GREATER_THAN: '>';
GREATER_THAN_EQUAL: '>=';
SIGNED_COMPARISON: '<=>';
BITWISE_OR: '|';
BITWISE_XOR: '^';
BITWISE_AND: '&';
LEFT_SHIFT: '<<';
RIGHT_SHIFT: '>>';
LEFT_SHIFT_COMPLETENESS: '<<<';
RIGHT_SHIFT_COMPLETENESS: '>>>';
PLUS: '+';
MINUS: '-';
MULTIPLICATION: '*';
UNSIGNED_DIVISION: '/';
SIGNED_DIVISION: '//';
PERCENT: '%'; //Also is the signed module operator
SIGNED_MODULE: '%%';
BITWISE_NOT: '~';
BOOLEAN_NOT: '!';
DOLLAR: '$';
DOUBLE_DOLLAR: '$$';

AAA: 'aaa';
AAD: 'aad';
AAM: 'aam';
AAS: 'aas';
ADC: 'adc';
ADD: 'add';
AND: 'and';
ARPL: 'arpl';
BB0_RESET: 'bb0_reset';
BB1_RESET: 'bb1_reset';
BOUND: 'bound';
BSF: 'bsf';
BSR: 'bsr';
BSWAP: 'bswap';
BT: 'bt';
BTC: 'btc';
BTR: 'btr';
BTS: 'bts';
CALL: 'call';
CBW: 'cbw';
CDQ: 'cdq';
CDQE: 'cdqe';
CLC: 'clc';
CLD: 'cld';
CLI: 'cli';
CLTS: 'clts';
CMC: 'cmc';
CMOVA: 'cmova';
CMOVAE: 'cmovae';
CMOVB: 'cmovb';
CMOVBE: 'cmovbe';
CMOVC: 'cmovc';
CMOVE: 'cmove';
CMOVGE: 'cmovge';
CMOVL: 'cmovl';
CMOVLE: 'cmovle';
CMOVNA: 'cmovna';
CMOVNAE: 'cmovnae';
CMOVNB: 'cmovnb';
CMOVNBE: 'cmovnbe';
CMOVNC: 'cmovnc';
CMOVNE: 'cmovne';
CMOVNG: 'cmovng';
CMOVNGE: 'cmovnge';
CMOVNL: 'cmovnl';
CMOVNO: 'cmovno';
CMOVNP: 'cmovnp';
CMOVNS: 'cmovns';
CMOVNZ: 'cmovnz';
CMOVO: 'cmovo';
CMOVP: 'cmovp';
CMOVPE: 'cmovpe';
CMOVPO: 'cmovpo';
CMOVS: 'cmovs';
CMOVZ: 'cmovz';
CMP: 'cmp';
CMPSB: 'cmpsb';
CMPSD: 'cmpsd';
CMPSQ: 'cmpsq';
CMPSW: 'cmpsw';
CMPXCHG: 'cmpxchg';
CMPXCHG16B: 'cmpxchg16b';
CMPXCHG486: 'cmpxchg486';
CMPXCHG8B: 'cmpxchg8b';
CPU_READ: 'cpu_read';
CPU_WRITE: 'cpu_write';
CPUID: 'cpuid';
CQO: 'cqo';
CWD: 'cwd';
CWDE: 'cwde';
DAA: 'daa';
DAS: 'das';
DEC: 'dec';
DIV: 'div';
DMINT: 'dmint';
EMMS: 'emms';
ENTER: 'enter';
EQU: 'equ';
F2XM1: 'f2xm1';
FABS: 'fabs';
FADD: 'fadd';
FADDP: 'faddp';
FBLD: 'fbld';
FBSTP: 'fbstp';
FCHS: 'fchs';
FCLEX: 'fclex';
FCMOVB: 'fcmovb';
FCMOVBE: 'fcmovbe';
FCMOVE: 'fcmove';
FCMOVNB: 'fcmovnb';
FCMOVNBE: 'fcmovnbe';
FCMOVNE: 'fcmovne';
FCMOVNU: 'fcmovnu';
FCMOVU: 'fcmovu';
FCOM: 'fcom';
FCOMI: 'fcomi';
FCOMIP: 'fcomip';
FCOMP: 'fcomp';
FCOMPP: 'fcompp';
FCOS: 'fcos';
FDECSTP: 'fdecstp';
FDISI: 'fdisi';
FDIV: 'fdiv';
FDIVP: 'fdivp';
FDIVR: 'fdivr';
FDIVRP: 'fdivrp';
FEMMS: 'femms';
FENI: 'feni';
FFREE: 'ffree';
FFREEP: 'ffreep';
FIADD: 'fiadd';
FICOM: 'ficom';
FICOMP: 'ficomp';
FIDIV: 'fidiv';
FIDIVR: 'fidivr';
FILD: 'fild';
FIMUL: 'fimul';
FINCSTP: 'fincstp';
FINIT: 'finit';
FIST: 'fist';
FISTP: 'fistp';
FISTTP: 'fisttp';
FISUB: 'fisub';
FISUBR: 'fisubr';
FLD: 'fld';
FLD1: 'fld1';
FLDCW: 'fldcw';
FLDENV: 'fldenv';
FLDL2E: 'fldl2e';
FLDL2T: 'fldl2t';
FLDLG2: 'fldlg2';
FLDLN2: 'fldln2';
FLDPI: 'fldpi';
FLDZ: 'fldz';
FMUL: 'fmul';
FMULP: 'fmulp';
FNCLEX: 'fnclex';
FNDISI: 'fndisi';
FNENI: 'fneni';
FNINIT: 'fninit';
FNOP: 'fnop';
FNSAVE: 'fnsave';
FNSTCW: 'fnstcw';
FNSTENV: 'fnstenv';
FNSTSW: 'fnstsw';
FPATAN: 'fpatan';
FPREM: 'fprem';
FPREM1: 'fprem1';
FPTAN: 'fptan';
FRNDINT: 'frndint';
FRSTOR: 'frstor';
FSAVE: 'fsave';
FSCALE: 'fscale';
FSETPM: 'fsetpm';
FSIN: 'fsin';
FSINCOS: 'fsincos';
FSQRT: 'fsqrt';
FST: 'fst';
FSTCW: 'fstcw';
FSTENV: 'fstenv';
FSTP: 'fstp';
FSTSW: 'fstsw';
FSUB: 'fsub';
FSUBP: 'fsubp';
FSUBR: 'fsubr';
FSUBRP: 'fsubrp';
FTST: 'ftst';
FUCOM: 'fucom';
FUCOMI: 'fucomi';
FUCOMIP: 'fucomip';
FUCOMP: 'fucomp';
FUCOMPP: 'fucompp';
FWAIT: 'fwait';
FXAM: 'fxam';
FXCH: 'fxch';
FXTRACT: 'fxtract';
FYL2X: 'fyl2x';
FYL2XP1: 'fyl2xp1';
HLT: 'hlt';
IBTS: 'ibts';
ICEBP: 'icebp';
IDIV: 'idiv';
IMUL: 'imul';
IN: 'in';
INC: 'inc';
INSB: 'insb';
INSD: 'insd';
INSW: 'insw';
INT: 'int';
INT01: 'int01';
INT03: 'int03';
INT1: 'int1';
INT3: 'int3';
INTO: 'into';
INVD: 'invd';
INVLPG: 'invlpg';
INVLPGA: 'invlpga';
INVPCID: 'invpcid';
IRET: 'iret';
IRETD: 'iretd';
IRETQ: 'iretq';
IRETW: 'iretw';
JA: 'ja';
JAE: 'jae';
JB: 'jb';
JBE: 'jbe';
JC: 'jc';
JCXZ: 'jcxz';
JE: 'je';
JECXZ: 'jecxz';
JG: 'jg';
JGE: 'jge';
JL: 'jl';
JLE: 'jle';
JMP: 'jmp';
JMPE: 'jmpe';
JNA: 'jna';
JNAE: 'jnae';
JNB: 'jnb';
JNBE: 'jnbe';
JNC: 'jnc';
JNE: 'jne';
JNG: 'jng';
JNGE: 'jnge';
JNL: 'jnl';
JNLE: 'jnle';
JNO: 'jno';
JNP: 'jnp';
JNS: 'jns';
JNZ: 'jnz';
JO: 'jo';
JP: 'jp';
JPE: 'jpe';
JPO: 'jpo';
JRCXZ: 'jrcxz';
JS: 'js';
JZ: 'jz';
LAHF: 'lahf';
LAR: 'lar';
LDS: 'lds';
LEA: 'lea';
LEAVE: 'leave';
LES: 'les';
LFENCE: 'lfence';
LFS: 'lfs';
LGDT: 'lgdt';
LGS: 'lgs';
LIDT: 'lidt';
LLDT: 'lldt';
LMSW: 'lmsw';
LOADALL: 'loadall';
LOADALL286: 'loadall286';
LODSB: 'lodsb';
LODSD: 'lodsd';
LODSQ: 'lodsq';
LODSW: 'lodsw';
LOOP: 'loop';
LOOPE: 'loope';
LOOPNE: 'loopne';
LOOPNZ: 'loopnz';
LOOPZ: 'loopz';
LSL: 'lsl';
LSS: 'lss';
LTR: 'ltr';
MFENCE: 'mfence';
MONITOR: 'monitor';
MONITORX: 'monitorx';
MOV: 'mov';
MOVD: 'movd';
MOVQ: 'movq';
MOVSB: 'movsb';
MOVSD: 'movsd';
MOVSQ: 'movsq';
MOVSW: 'movsw';
MOVSX: 'movsx';
MOVSXD: 'movsxd';
MOVZX: 'movzx';
MUL: 'mul';
MWAIT: 'mwait';
MWAITX: 'mwaitx';
NEG: 'neg';
NOP: 'nop';
NOT: 'not';
OR: 'or';
OUT: 'out';
OUTSB: 'outsb';
OUTSD: 'outsd';
OUTSW: 'outsw';
PACKSSDW: 'packssdw';
PACKSSWB: 'packsswb';
PACKUSWB: 'packuswb';
PADDB: 'paddb';
PADDD: 'paddd';
PADDSB: 'paddsb';
PADDSIW: 'paddsiw';
PADDSW: 'paddsw';
PADDUSB: 'paddusb';
PADDUSW: 'paddusw';
PADDW: 'paddw';
PAND: 'pand';
PANDN: 'pandn';
PAUSE: 'pause';
PAVEB: 'paveb';
PAVGUSB: 'pavgusb';
PCMPEQB: 'pcmpeqb';
PCMPEQD: 'pcmpeqd';
PCMPEQW: 'pcmpeqw';
PCMPGTB: 'pcmpgtb';
PCMPGTD: 'pcmpgtd';
PCMPGTW: 'pcmpgtw';
PDISTIB: 'pdistib';
PF2ID: 'pf2id';
PFACC: 'pfacc';
PFADD: 'pfadd';
PFCMPEQ: 'pfcmpeq';
PFCMPGE: 'pfcmpge';
PFCMPGT: 'pfcmpgt';
PFMAX: 'pfmax';
PFMIN: 'pfmin';
PFMUL: 'pfmul';
PFRCP: 'pfrcp';
PFRCPIT1: 'pfrcpit1';
PFRCPIT2: 'pfrcpit2';
PFRSQIT1: 'pfrsqit1';
PFRSQRT: 'pfrsqrt';
PFSUB: 'pfsub';
PFSUBR: 'pfsubr';
PI2FD: 'pi2fd';
PMACHRIW: 'pmachriw';
PMADDWD: 'pmaddwd';
PMAGW: 'pmagw';
PMULHRIW: 'pmulhriw';
PMULHRWA: 'pmulhrwa';
PMULHRWC: 'pmulhrwc';
PMULHW: 'pmulhw';
PMULLW: 'pmullw';
PMVGEZB: 'pmvgezb';
PMVLZB: 'pmvlzb';
PMVNZB: 'pmvnzb';
PMVZB: 'pmvzb';
POP: 'pop';
POPA: 'popa';
POPAD: 'popad';
POPAW: 'popaw';
POPF: 'popf';
POPFD: 'popfd';
POPFQ: 'popfq';
POPFW: 'popfw';
POR: 'por';
PREFETCH: 'prefetch';
PREFETCHW: 'prefetchw';
PSLLD: 'pslld';
PSLLQ: 'psllq';
PSLLW: 'psllw';
PSRAD: 'psrad';
PSRAW: 'psraw';
PSRLD: 'psrld';
PSRLQ: 'psrlq';
PSRLW: 'psrlw';
PSUBB: 'psubb';
PSUBD: 'psubd';
PSUBSB: 'psubsb';
PSUBSIW: 'psubsiw';
PSUBSW: 'psubsw';
PSUBUSB: 'psubusb';
PSUBUSW: 'psubusw';
PSUBW: 'psubw';
PUNPCKHBW: 'punpckhbw';
PUNPCKHDQ: 'punpckhdq';
PUNPCKHWD: 'punpckhwd';
PUNPCKLBW: 'punpcklbw';
PUNPCKLDQ: 'punpckldq';
PUNPCKLWD: 'punpcklwd';
PUSH: 'push';
PUSHA: 'pusha';
PUSHAD: 'pushad';
PUSHAW: 'pushaw';
PUSHF: 'pushf';
PUSHFD: 'pushfd';
PUSHFQ: 'pushfq';
PUSHFW: 'pushfw';
PXOR: 'pxor';
RCL: 'rcl';
RCR: 'rcr';
RDM: 'rdm';
RDMSR: 'rdmsr';
RDPMC: 'rdpmc';
RDSHR: 'rdshr';
RDTSC: 'rdtsc';
RDTSCP: 'rdtscp';
RET: 'ret';
RETD: 'retd';
RETF: 'retf';
RETFD: 'retfd';
RETFQ: 'retfq';
RETFW: 'retfw';
RETN: 'retn';
RETND: 'retnd';
RETNQ: 'retnq';
RETNW: 'retnw';
RETQ: 'retq';
RETW: 'retw';
ROL: 'rol';
ROR: 'ror';
RSDC: 'rsdc';
RSLDT: 'rsldt';
RSM: 'rsm';
RSTS: 'rsts';
SAHF: 'sahf';
SAL: 'sal';
SALC: 'salc';
SAR: 'sar';
SBB: 'sbb';
SCASB: 'scasb';
SCASD: 'scasd';
SCASQ: 'scasq';
SCASW: 'scasw';
SETA: 'seta';
SETAE: 'setae';
SETB: 'setb';
SETBE: 'setbe';
SETC: 'setc';
SETE: 'sete';
SETG: 'setg';
SETGE: 'setge';
SETL: 'setl';
SETLE: 'setle';
SETNA: 'setna';
SETNAE: 'setnae';
SETNB: 'setnb';
SETNBE: 'setnbe';
SETNC: 'setnc';
SETNE: 'setne';
SETNG: 'setng';
SETNGE: 'setnge';
SETNL: 'setnl';
SETNLE: 'setnle';
SETNO: 'setno';
SETNP: 'setnp';
SETNS: 'setns';
SETNZ: 'setnz';
SETO: 'seto';
SETP: 'setp';
SETPE: 'setpe';
SETPO: 'setpo';
SETS: 'sets';
SETZ: 'setz';
SFENCE: 'sfence';
SGDT: 'sgdt';
SHL: 'shl';
SHLD: 'shld';
SHR: 'shr';
SHRD: 'shrd';
SIDT: 'sidt';
SKINIT: 'skinit';
SLDT: 'sldt';
SMI: 'smi';
SMINT: 'smint';
SMINTOLD: 'smintold';
SMSW: 'smsw';
STC: 'stc';
STD: 'std';
STI: 'sti';
STOSB: 'stosb';
STOSD: 'stosd';
STOSQ: 'stosq';
STOSW: 'stosw';
STR: 'str';
SUB: 'sub';
SVDC: 'svdc';
SVLDT: 'svldt';
SVTS: 'svts';
SWAPGS: 'swapgs';
SYSCALL: 'syscall';
SYSENTER: 'sysenter';
SYSEXIT: 'sysexit';
SYSRET: 'sysret';
TEST: 'test';
UD0: 'ud0';
UD1: 'ud1';
UD2: 'ud2';
UD2A: 'ud2a';
UD2B: 'ud2b';
UMOV: 'umov';
VERR: 'verr';
VERW: 'verw';
WBINVD: 'wbinvd';
WRMSR: 'wrmsr';
WRSHR: 'wrshr';
XADD: 'xadd';
XBTS: 'xbts';
XCHG: 'xchg';
XLAT: 'xlat';
XLATB: 'xlatb';
XOR: 'xor';


AL: 'al';
AH: 'ah';
AX: 'ax';
EAX: 'eax';
RAX: 'rax';
BL: 'bl';
BH: 'bh';
BX: 'bx';
EBX: 'ebx';
RBX: 'rbx';
CL: 'cl';
CH: 'ch';
CX: 'cx';
ECX: 'ecx';
RCX: 'rcx';
DL: 'dl';
DH: 'dh';
DX: 'dx';
EDX: 'edx';
RDX: 'rdx';
SPL: 'spl';
SP: 'sp';
ESP: 'esp';
RSP: 'rsp';
BPL: 'bpl';
BP: 'bp';
EBP: 'ebp';
RBP: 'rbp';
SIL: 'sil';
SI: 'si';
ESI: 'esi';
RSI: 'rsi';
DIL: 'dil';
DI: 'di';
EDI: 'edi';
RDI: 'rdi';
R8B: 'r8b';
R9B: 'r9b';
R10B: 'r10b';
R11B: 'r11b';
R12B: 'r12b';
R13B: 'r13b';
R14B: 'r14b';
R15B: 'r15b';
R8W: 'r8w';
R9W: 'r9w';
R10W: 'r10w';
R11W: 'r11w';
R12W: 'r12w';
R13W: 'r13w';
R14W: 'r14w';
R15W: 'r15w';
R8D: 'r8d';
R9D: 'r9d';
R10D: 'r10d';
R11D: 'r11d';
R12D: 'r12d';
R13D: 'r13d';
R14D: 'r14d';
R15D: 'r15d';
R8: 'r8';
R9: 'r9';
R10: 'r10';
R11: 'r11';
R12: 'r12';
R13: 'r13';
R14: 'r14';
R15: 'r15';
IP: 'ip';
EIP: 'eip';
RIP: 'rip';
ES: 'es';
CS: 'cs';
SS: 'ss';
DS: 'ds';
FS: 'fs';
GS: 'gs';
SEGR6: 'segr6';
SEGR7: 'segr7';
CR0: 'cr0';
CR1: 'cr1';
CR2: 'cr2';
CR3: 'cr3';
CR4: 'cr4';
CR5: 'cr5';
CR6: 'cr6';
CR7: 'cr7';
CR8: 'cr8';
CR9: 'cr9';
CR10: 'cr10';
CR11: 'cr11';
CR12: 'cr12';
CR13: 'cr13';
CR14: 'cr14';
CR15: 'cr15';
DR0: 'dr0';
DR1: 'dr1';
DR2: 'dr2';
DR3: 'dr3';
DR4: 'dr4';
DR5: 'dr5';
DR6: 'dr6';
DR7: 'dr7';
DR8: 'dr8';
DR9: 'dr9';
DR10: 'dr10';
DR11: 'dr11';
DR12: 'dr12';
DR13: 'dr13';
DR14: 'dr14';
DR15: 'dr15';
TR0: 'tr0';
TR1: 'tr1';
TR2: 'tr2';
TR3: 'tr3';
TR4: 'tr4';
TR5: 'tr5';
TR6: 'tr6';
TR7: 'tr7';
ST0: 'st0';
ST1: 'st1';
ST2: 'st2';
ST3: 'st3';
ST4: 'st4';
ST5: 'st5';
ST6: 'st6';
ST7: 'st7';
MM0: 'mm0';
MM1: 'mm1';
MM2: 'mm2';
MM3: 'mm3';
MM4: 'mm4';
MM5: 'mm5';
MM6: 'mm6';
MM7: 'mm7';
XMM0: 'xmm0';
XMM1: 'xmm1';
XMM2: 'xmm2';
XMM3: 'xmm3';
XMM4: 'xmm4';
XMM5: 'xmm5';
XMM6: 'xmm6';
XMM7: 'xmm7';
XMM8: 'xmm8';
XMM9: 'xmm9';
XMM10: 'xmm10';
XMM11: 'xmm11';
XMM12: 'xmm12';
XMM13: 'xmm13';
XMM14: 'xmm14';
XMM15: 'xmm15';
XMM16: 'xmm16';
XMM17: 'xmm17';
XMM18: 'xmm18';
XMM19: 'xmm19';
XMM20: 'xmm20';
XMM21: 'xmm21';
XMM22: 'xmm22';
XMM23: 'xmm23';
XMM24: 'xmm24';
XMM25: 'xmm25';
XMM26: 'xmm26';
XMM27: 'xmm27';
XMM28: 'xmm28';
XMM29: 'xmm29';
XMM30: 'xmm30';
XMM31: 'xmm31';
YMM0: 'ymm0';
YMM1: 'ymm1';
YMM2: 'ymm2';
YMM3: 'ymm3';
YMM4: 'ymm4';
YMM5: 'ymm5';
YMM6: 'ymm6';
YMM7: 'ymm7';
YMM8: 'ymm8';
YMM9: 'ymm9';
YMM10: 'ymm10';
YMM11: 'ymm11';
YMM12: 'ymm12';
YMM13: 'ymm13';
YMM14: 'ymm14';
YMM15: 'ymm15';
YMM16: 'ymm16';
YMM17: 'ymm17';
YMM18: 'ymm18';
YMM19: 'ymm19';
YMM20: 'ymm20';
YMM21: 'ymm21';
YMM22: 'ymm22';
YMM23: 'ymm23';
YMM24: 'ymm24';
YMM25: 'ymm25';
YMM26: 'ymm26';
YMM27: 'ymm27';
YMM28: 'ymm28';
YMM29: 'ymm29';
YMM30: 'ymm30';
YMM31: 'ymm31';
ZMM0: 'zmm0';
ZMM1: 'zmm1';
ZMM2: 'zmm2';
ZMM3: 'zmm3';
ZMM4: 'zmm4';
ZMM5: 'zmm5';
ZMM6: 'zmm6';
ZMM7: 'zmm7';
ZMM8: 'zmm8';
ZMM9: 'zmm9';
ZMM10: 'zmm10';
ZMM11: 'zmm11';
ZMM12: 'zmm12';
ZMM13: 'zmm13';
ZMM14: 'zmm14';
ZMM15: 'zmm15';
ZMM16: 'zmm16';
ZMM17: 'zmm17';
ZMM18: 'zmm18';
ZMM19: 'zmm19';
ZMM20: 'zmm20';
ZMM21: 'zmm21';
ZMM22: 'zmm22';
ZMM23: 'zmm23';
ZMM24: 'zmm24';
ZMM25: 'zmm25';
ZMM26: 'zmm26';
ZMM27: 'zmm27';
ZMM28: 'zmm28';
ZMM29: 'zmm29';
ZMM30: 'zmm30';
ZMM31: 'zmm31';
TMM0: 'tmm0';
TMM1: 'tmm1';
TMM2: 'tmm2';
TMM3: 'tmm3';
TMM4: 'tmm4';
TMM5: 'tmm5';
TMM6: 'tmm6';
TMM7: 'tmm7';
K0: 'k0';
K1: 'k1';
K2: 'k2';
K3: 'k3';
K4: 'k4';
K5: 'k5';
K6: 'k6';
K7: 'k7';
BND0: 'bnd0';
BND1: 'bnd1';
BND2: 'bnd2';
BND3: 'bnd3';


AADD: 'aadd';
AAND: 'aand';
ADCX: 'adcx';
ADDPD: 'addpd';
ADDPS: 'addps';
ADDSD: 'addsd';
ADDSS: 'addss';
ADDSUBPD: 'addsubpd';
ADDSUBPS: 'addsubps';
ADOX: 'adox';
AESDEC: 'aesdec';
AESDECLAST: 'aesdeclast';
AESENC: 'aesenc';
AESENCLAST: 'aesenclast';
AESIMC: 'aesimc';
AESKEYGENASSIST: 'aeskeygenassist';
ANDN: 'andn';
ANDNPD: 'andnpd';
ANDNPS: 'andnps';
ANDPD: 'andpd';
ANDPS: 'andps';
AXOR: 'axor';
BEXTR: 'bextr';
BLCFILL: 'blcfill';
BLCI: 'blci';
BLCIC: 'blcic';
BLCMSK: 'blcmsk';
BLCS: 'blcs';
BLENDPD: 'blendpd';
BLENDPS: 'blendps';
BLENDVPD: 'blendvpd';
BLENDVPS: 'blendvps';
BLSFILL: 'blsfill';
BLSI: 'blsi';
BLSIC: 'blsic';
BLSMSK: 'blsmsk';
BLSR: 'blsr';
BNDCL: 'bndcl';
BNDCN: 'bndcn';
BNDCU: 'bndcu';
BNDLDX: 'bndldx';
BNDMK: 'bndmk';
BNDMOV: 'bndmov';
BNDSTX: 'bndstx';
BZHI: 'bzhi';
CLAC: 'clac';
CLDEMOTE: 'cldemote';
CLFLUSH: 'clflush';
CLFLUSHOPT: 'clflushopt';
CLGI: 'clgi';
CLRSSBSY: 'clrssbsy';
CLUI: 'clui';
CLWB: 'clwb';
CLZERO: 'clzero';
CMPEQPD: 'cmpeqpd';
CMPEQPS: 'cmpeqps';
CMPEQSD: 'cmpeqsd';
CMPEQSS: 'cmpeqss';
CMPLEPD: 'cmplepd';
CMPLEPS: 'cmpleps';
CMPLESD: 'cmplesd';
CMPLESS: 'cmpless';
CMPLTPD: 'cmpltpd';
CMPLTPS: 'cmpltps';
CMPLTSD: 'cmpltsd';
CMPLTSS: 'cmpltss';
CMPNEQPD: 'cmpneqpd';
CMPNEQPS: 'cmpneqps';
CMPNEQSD: 'cmpneqsd';
CMPNEQSS: 'cmpneqss';
CMPNLEPD: 'cmpnlepd';
CMPNLEPS: 'cmpnleps';
CMPNLESD: 'cmpnlesd';
CMPNLESS: 'cmpnless';
CMPNLTPD: 'cmpnltpd';
CMPNLTPS: 'cmpnltps';
CMPNLTSD: 'cmpnltsd';
CMPNLTSS: 'cmpnltss';
CMPNPXADD: 'cmpnpxadd';
CMPNSXADD: 'cmpnsxadd';
CMPNZXADD: 'cmpnzxadd';
CMPORDPD: 'cmpordpd';
CMPORDPS: 'cmpordps';
CMPORDSD: 'cmpordsd';
CMPORDSS: 'cmpordss';
CMPOXADD: 'cmpoxadd';
CMPPD: 'cmppd';
CMPPS: 'cmpps';
CMPPXADD: 'cmppxadd';
CMPSS: 'cmpss';
CMPSXADD: 'cmpsxadd';
CMPUNORDPD: 'cmpunordpd';
CMPUNORDPS: 'cmpunordps';
CMPUNORDSD: 'cmpunordsd';
CMPUNORDSS: 'cmpunordss';
CMPZXADD: 'cmpzxadd';
COMISD: 'comisd';
COMISS: 'comiss';
CRC32: 'crc32';
CVTDQ2PD: 'cvtdq2pd';
CVTDQ2PS: 'cvtdq2ps';
CVTPD2DQ: 'cvtpd2dq';
CVTPD2PI: 'cvtpd2pi';
CVTPD2PS: 'cvtpd2ps';
CVTPI2PD: 'cvtpi2pd';
CVTPI2PS: 'cvtpi2ps';
CVTPS2DQ: 'cvtps2dq';
CVTPS2PD: 'cvtps2pd';
CVTPS2PI: 'cvtps2pi';
CVTSD2SI: 'cvtsd2si';
CVTSD2SS: 'cvtsd2ss';
CVTSI2SD: 'cvtsi2sd';
CVTSI2SS: 'cvtsi2ss';
CVTSS2SD: 'cvtss2sd';
CVTSS2SI: 'cvtss2si';
CVTTPD2DQ: 'cvttpd2dq';
CVTTPD2PI: 'cvttpd2pi';
CVTTPS2DQ: 'cvttps2dq';
CVTTPS2PI: 'cvttps2pi';
CVTTSD2SI: 'cvttsd2si';
CVTTSS2SI: 'cvttss2si';
DIVPD: 'divpd';
DIVPS: 'divps';
DIVSD: 'divsd';
DIVSS: 'divss';
DPPD: 'dppd';
DPPS: 'dpps';
ENCLS: 'encls';
ENCLU: 'enclu';
ENCLV: 'enclv';
ENDBR32: 'endbr32';
ENDBR64: 'endbr64';
ENQCMD: 'enqcmd';
ENQCMDS: 'enqcmds';
EXTRACTPS: 'extractps';
EXTRQ: 'extrq';
FXRSTOR: 'fxrstor';
FXRSTOR64: 'fxrstor64';
FXSAVE: 'fxsave';
FXSAVE64: 'fxsave64';
GETSEC: 'getsec';
GF2P8AFFINEINVQB: 'gf2p8affineinvqb';
GF2P8AFFINEQB: 'gf2p8affineqb';
GF2P8MULB: 'gf2p8mulb';
HADDPD: 'haddpd';
HADDPS: 'haddps';
HINT_NOP0: 'hint_nop0';
HINT_NOP1: 'hint_nop1';
HINT_NOP10: 'hint_nop10';
HINT_NOP11: 'hint_nop11';
HINT_NOP12: 'hint_nop12';
HINT_NOP13: 'hint_nop13';
HINT_NOP14: 'hint_nop14';
HINT_NOP15: 'hint_nop15';
HINT_NOP16: 'hint_nop16';
HINT_NOP17: 'hint_nop17';
HINT_NOP18: 'hint_nop18';
HINT_NOP19: 'hint_nop19';
HINT_NOP2: 'hint_nop2';
HINT_NOP20: 'hint_nop20';
HINT_NOP21: 'hint_nop21';
HINT_NOP22: 'hint_nop22';
HINT_NOP23: 'hint_nop23';
HINT_NOP24: 'hint_nop24';
HINT_NOP25: 'hint_nop25';
HINT_NOP26: 'hint_nop26';
HINT_NOP27: 'hint_nop27';
HINT_NOP28: 'hint_nop28';
HINT_NOP29: 'hint_nop29';
HINT_NOP3: 'hint_nop3';
HINT_NOP30: 'hint_nop30';
HINT_NOP31: 'hint_nop31';
HINT_NOP32: 'hint_nop32';
HINT_NOP33: 'hint_nop33';
HINT_NOP34: 'hint_nop34';
HINT_NOP35: 'hint_nop35';
HINT_NOP36: 'hint_nop36';
HINT_NOP37: 'hint_nop37';
HINT_NOP38: 'hint_nop38';
HINT_NOP39: 'hint_nop39';
HINT_NOP4: 'hint_nop4';
HINT_NOP40: 'hint_nop40';
HINT_NOP41: 'hint_nop41';
HINT_NOP42: 'hint_nop42';
HINT_NOP43: 'hint_nop43';
HINT_NOP44: 'hint_nop44';
HINT_NOP45: 'hint_nop45';
HINT_NOP46: 'hint_nop46';
HINT_NOP47: 'hint_nop47';
HINT_NOP48: 'hint_nop48';
HINT_NOP49: 'hint_nop49';
HINT_NOP5: 'hint_nop5';
HINT_NOP50: 'hint_nop50';
HINT_NOP51: 'hint_nop51';
HINT_NOP52: 'hint_nop52';
HINT_NOP53: 'hint_nop53';
HINT_NOP54: 'hint_nop54';
HINT_NOP55: 'hint_nop55';
HINT_NOP56: 'hint_nop56';
HINT_NOP57: 'hint_nop57';
HINT_NOP58: 'hint_nop58';
HINT_NOP59: 'hint_nop59';
HINT_NOP6: 'hint_nop6';
HINT_NOP60: 'hint_nop60';
HINT_NOP61: 'hint_nop61';
HINT_NOP62: 'hint_nop62';
HINT_NOP63: 'hint_nop63';
HINT_NOP7: 'hint_nop7';
HINT_NOP8: 'hint_nop8';
HINT_NOP9: 'hint_nop9';
HRESET: 'hreset';
HSUBPD: 'hsubpd';
HSUBPS: 'hsubps';
INCSSPD: 'incsspd';
INCSSPQ: 'incsspq';
INSERTPS: 'insertps';
INSERTQ: 'insertq';
INVEPT: 'invept';
INVVPID: 'invvpid';
KADD: 'kadd';
KADDB: 'kaddb';
KADDD: 'kaddd';
KADDQ: 'kaddq';
KADDW: 'kaddw';
KAND: 'kand';
KANDB: 'kandb';
KANDD: 'kandd';
KANDN: 'kandn';
KANDNB: 'kandnb';
KANDND: 'kandnd';
KANDNQ: 'kandnq';
KANDNW: 'kandnw';
KANDQ: 'kandq';
KANDW: 'kandw';
KMOV: 'kmov';
KMOVB: 'kmovb';
KMOVD: 'kmovd';
KMOVQ: 'kmovq';
KMOVW: 'kmovw';
KNOT: 'knot';
KNOTB: 'knotb';
KNOTD: 'knotd';
KNOTQ: 'knotq';
KNOTW: 'knotw';
KOR: 'kor';
KORB: 'korb';
KORD: 'kord';
KORQ: 'korq';
KORTEST: 'kortest';
KORTESTB: 'kortestb';
KORTESTD: 'kortestd';
KORTESTQ: 'kortestq';
KORTESTW: 'kortestw';
KORW: 'korw';
KSHIFTL: 'kshiftl';
KSHIFTLB: 'kshiftlb';
KSHIFTLD: 'kshiftld';
KSHIFTLQ: 'kshiftlq';
KSHIFTLW: 'kshiftlw';
KSHIFTR: 'kshiftr';
KSHIFTRB: 'kshiftrb';
KSHIFTRD: 'kshiftrd';
KSHIFTRQ: 'kshiftrq';
KSHIFTRW: 'kshiftrw';
KTEST: 'ktest';
KTESTB: 'ktestb';
KTESTD: 'ktestd';
KTESTQ: 'ktestq';
KTESTW: 'ktestw';
KUNPCK: 'kunpck';
KUNPCKBW: 'kunpckbw';
KUNPCKDQ: 'kunpckdq';
KUNPCKWD: 'kunpckwd';
KXNOR: 'kxnor';
KXNORB: 'kxnorb';
KXNORD: 'kxnord';
KXNORQ: 'kxnorq';
KXNORW: 'kxnorw';
KXOR: 'kxor';
KXORB: 'kxorb';
KXORD: 'kxord';
KXORQ: 'kxorq';
KXORW: 'kxorw';
LDDQU: 'lddqu';
LDMXCSR: 'ldmxcsr';
LDTILECFG: 'ldtilecfg';
LLWPCB: 'llwpcb';
LWPINS: 'lwpins';
LWPVAL: 'lwpval';
LZCNT: 'lzcnt';
MASKMOVDQU: 'maskmovdqu';
MASKMOVQ: 'maskmovq';
MAXPD: 'maxpd';
MAXPS: 'maxps';
MAXSD: 'maxsd';
MAXSS: 'maxss';
MINPD: 'minpd';
MINPS: 'minps';
MINSD: 'minsd';
MINSS: 'minss';
MONTMUL: 'montmul';
MOVAPD: 'movapd';
MOVAPS: 'movaps';
MOVBE: 'movbe';
MOVDDUP: 'movddup';
MOVDIR64B: 'movdir64b';
MOVDIRI: 'movdiri';
MOVDQ2Q: 'movdq2q';
MOVDQA: 'movdqa';
MOVDQU: 'movdqu';
MOVHLPS: 'movhlps';
MOVHPD: 'movhpd';
MOVHPS: 'movhps';
MOVLHPS: 'movlhps';
MOVLPD: 'movlpd';
MOVLPS: 'movlps';
MOVMSKPD: 'movmskpd';
MOVMSKPS: 'movmskps';
MOVNTDQ: 'movntdq';
MOVNTDQA: 'movntdqa';
MOVNTI: 'movnti';
MOVNTPD: 'movntpd';
MOVNTPS: 'movntps';
MOVNTQ: 'movntq';
MOVNTSD: 'movntsd';
MOVNTSS: 'movntss';
MOVQ2DQ: 'movq2dq';
MOVSHDUP: 'movshdup';
MOVSLDUP: 'movsldup';
MOVSS: 'movss';
MOVUPD: 'movupd';
MOVUPS: 'movups';
MPSADBW: 'mpsadbw';
MULPD: 'mulpd';
MULPS: 'mulps';
MULSD: 'mulsd';
MULSS: 'mulss';
MULX: 'mulx';
ORPD: 'orpd';
ORPS: 'orps';
PABSB: 'pabsb';
PABSD: 'pabsd';
PABSW: 'pabsw';
PACKUSDW: 'packusdw';
PADDQ: 'paddq';
PALIGNR: 'palignr';
PAVGB: 'pavgb';
PAVGW: 'pavgw';
PBLENDVB: 'pblendvb';
PBLENDW: 'pblendw';
PCLMULHQHQDQ: 'pclmulhqhqdq';
PCLMULHQLQDQ: 'pclmulhqlqdq';
PCLMULLQHQDQ: 'pclmullqhqdq';
PCLMULLQLQDQ: 'pclmullqlqdq';
PCLMULQDQ: 'pclmulqdq';
PCMPEQQ: 'pcmpeqq';
PCMPESTRI: 'pcmpestri';
PCMPESTRM: 'pcmpestrm';
PCMPGTQ: 'pcmpgtq';
PCMPISTRI: 'pcmpistri';
PCMPISTRM: 'pcmpistrm';
PCOMMIT: 'pcommit';
PCONFIG: 'pconfig';
PDEP: 'pdep';
PEXT: 'pext';
PEXTRB: 'pextrb';
PEXTRD: 'pextrd';
PEXTRQ: 'pextrq';
PEXTRW: 'pextrw';
PF2IW: 'pf2iw';
PFNACC: 'pfnacc';
PFPNACC: 'pfpnacc';
PFRCPV: 'pfrcpv';
PFRSQRTV: 'pfrsqrtv';
PHADDD: 'phaddd';
PHADDSW: 'phaddsw';
PHADDW: 'phaddw';
PHMINPOSUW: 'phminposuw';
PHSUBD: 'phsubd';
PHSUBSW: 'phsubsw';
PHSUBW: 'phsubw';
PI2FW: 'pi2fw';
PINSRB: 'pinsrb';
PINSRD: 'pinsrd';
PINSRQ: 'pinsrq';
PINSRW: 'pinsrw';
PMADDUBSW: 'pmaddubsw';
PMAXSB: 'pmaxsb';
PMAXSD: 'pmaxsd';
PMAXSW: 'pmaxsw';
PMAXUB: 'pmaxub';
PMAXUD: 'pmaxud';
PMAXUW: 'pmaxuw';
PMINSB: 'pminsb';
PMINSD: 'pminsd';
PMINSW: 'pminsw';
PMINUB: 'pminub';
PMINUD: 'pminud';
PMINUW: 'pminuw';
PMOVMSKB: 'pmovmskb';
PMOVSXBD: 'pmovsxbd';
PMOVSXBQ: 'pmovsxbq';
PMOVSXBW: 'pmovsxbw';
PMOVSXDQ: 'pmovsxdq';
PMOVSXWD: 'pmovsxwd';
PMOVSXWQ: 'pmovsxwq';
PMOVZXBD: 'pmovzxbd';
PMOVZXBQ: 'pmovzxbq';
PMOVZXBW: 'pmovzxbw';
PMOVZXDQ: 'pmovzxdq';
PMOVZXWD: 'pmovzxwd';
PMOVZXWQ: 'pmovzxwq';
PMULDQ: 'pmuldq';
PMULHRSW: 'pmulhrsw';
PMULHUW: 'pmulhuw';
PMULLD: 'pmulld';
PMULUDQ: 'pmuludq';
POPCNT: 'popcnt';
PREFETCHIT0: 'prefetchit0';
PREFETCHIT1: 'prefetchit1';
PREFETCHNTA: 'prefetchnta';
PREFETCHT0: 'prefetcht0';
PREFETCHT1: 'prefetcht1';
PREFETCHT2: 'prefetcht2';
PREFETCHWT1: 'prefetchwt1';
PSADBW: 'psadbw';
PSHUFB: 'pshufb';
PSHUFD: 'pshufd';
PSHUFHW: 'pshufhw';
PSHUFLW: 'pshuflw';
PSHUFW: 'pshufw';
PSIGNB: 'psignb';
PSIGND: 'psignd';
PSIGNW: 'psignw';
PSLLDQ: 'pslldq';
PSRLDQ: 'psrldq';
PSUBQ: 'psubq';
PSWAPD: 'pswapd';
PTEST: 'ptest';
PTWRITE: 'ptwrite';
PUNPCKHQDQ: 'punpckhqdq';
PUNPCKLQDQ: 'punpcklqdq';
PVALIDATE: 'pvalidate';
RCPPS: 'rcpps';
RCPSS: 'rcpss';
RDFSBASE: 'rdfsbase';
RDGSBASE: 'rdgsbase';
RDMSRLIST: 'rdmsrlist';
RDPID: 'rdpid';
RDPKRU: 'rdpkru';
RDRAND: 'rdrand';
RDSEED: 'rdseed';
RDSSPD: 'rdsspd';
RDSSPQ: 'rdsspq';
RMPADJUST: 'rmpadjust';
RORX: 'rorx';
ROUNDPD: 'roundpd';
ROUNDPS: 'roundps';
ROUNDSD: 'roundsd';
ROUNDSS: 'roundss';
RSQRTPS: 'rsqrtps';
RSQRTSS: 'rsqrtss';
RSTORSSP: 'rstorssp';
SARX: 'sarx';
SAVEPREVSSP: 'saveprevssp';
SENDUIPI: 'senduipi';
SERIALIZE: 'serialize';
SETSSBSY: 'setssbsy';
SHA1MSG1: 'sha1msg1';
SHA1MSG2: 'sha1msg2';
SHA1NEXTE: 'sha1nexte';
SHA1RNDS4: 'sha1rnds4';
SHA256MSG1: 'sha256msg1';
SHA256MSG2: 'sha256msg2';
SHA256RNDS2: 'sha256rnds2';
SHLX: 'shlx';
SHRX: 'shrx';
SHUFPD: 'shufpd';
SHUFPS: 'shufps';
SLWPCB: 'slwpcb';
SQRTPD: 'sqrtpd';
SQRTPS: 'sqrtps';
SQRTSD: 'sqrtsd';
SQRTSS: 'sqrtss';
STAC: 'stac';
STGI: 'stgi';
STMXCSR: 'stmxcsr';
STTILECFG: 'sttilecfg';
STUI: 'stui';
SUBPD: 'subpd';
SUBPS: 'subps';
SUBSD: 'subsd';
SUBSS: 'subss';
T1MSKC: 't1mskc';
TDPBF16PS: 'tdpbf16ps';
TDPBSSD: 'tdpbssd';
TDPBSUD: 'tdpbsud';
TDPBUSD: 'tdpbusd';
TDPBUUD: 'tdpbuud';
TESTUI: 'testui';
TILELOADD: 'tileloadd';
TILELOADDT1: 'tileloaddt1';
TILERELEASE: 'tilerelease';
TILESTORED: 'tilestored';
TILEZERO: 'tilezero';
TPAUSE: 'tpause';
TZCNT: 'tzcnt';
TZMSK: 'tzmsk';
UCOMISD: 'ucomisd';
UCOMISS: 'ucomiss';
UIRET: 'uiret';
UMONITOR: 'umonitor';
UMWAIT: 'umwait';
UNPCKHPD: 'unpckhpd';
UNPCKHPS: 'unpckhps';
UNPCKLPD: 'unpcklpd';
UNPCKLPS: 'unpcklps';
V4DPWSSD: 'v4dpwssd';
V4DPWSSDS: 'v4dpwssds';
V4FMADDPS: 'v4fmaddps';
V4FMADDSS: 'v4fmaddss';
V4FNMADDPS: 'v4fnmaddps';
V4FNMADDSS: 'v4fnmaddss';
VADDPD: 'vaddpd';
VADDPH: 'vaddph';
VADDPS: 'vaddps';
VADDSD: 'vaddsd';
VADDSH: 'vaddsh';
VADDSS: 'vaddss';
VADDSUBPD: 'vaddsubpd';
VADDSUBPS: 'vaddsubps';
VAESDEC: 'vaesdec';
VAESDECLAST: 'vaesdeclast';
VAESENC: 'vaesenc';
VAESENCLAST: 'vaesenclast';
VAESIMC: 'vaesimc';
VAESKEYGENASSIST: 'vaeskeygenassist';
VALIGND: 'valignd';
VALIGNQ: 'valignq';
VANDNPD: 'vandnpd';
VANDNPS: 'vandnps';
VANDPD: 'vandpd';
VANDPS: 'vandps';
VBCSTNEBF16PS: 'vbcstnebf16ps';
VBCSTNESH2PS: 'vbcstnesh2ps';
VBLENDMPD: 'vblendmpd';
VBLENDMPS: 'vblendmps';
VBLENDPD: 'vblendpd';
VBLENDPS: 'vblendps';
VBLENDVPD: 'vblendvpd';
VBLENDVPS: 'vblendvps';
VBROADCASTF128: 'vbroadcastf128';
VBROADCASTF32X2: 'vbroadcastf32x2';
VBROADCASTF32X4: 'vbroadcastf32x4';
VBROADCASTF32X8: 'vbroadcastf32x8';
VBROADCASTF64X2: 'vbroadcastf64x2';
VBROADCASTF64X4: 'vbroadcastf64x4';
VBROADCASTI128: 'vbroadcasti128';
VBROADCASTI32X2: 'vbroadcasti32x2';
VBROADCASTI32X4: 'vbroadcasti32x4';
VBROADCASTI32X8: 'vbroadcasti32x8';
VBROADCASTI64X2: 'vbroadcasti64x2';
VBROADCASTI64X4: 'vbroadcasti64x4';
VBROADCASTSD: 'vbroadcastsd';
VBROADCASTSS: 'vbroadcastss';
VCMPEQ_OQPD: 'vcmpeq_oqpd';
VCMPEQ_OQPS: 'vcmpeq_oqps';
VCMPEQ_OQSD: 'vcmpeq_oqsd';
VCMPEQ_OQSS: 'vcmpeq_oqss';
VCMPEQ_OSPD: 'vcmpeq_ospd';
VCMPEQ_OSPS: 'vcmpeq_osps';
VCMPEQ_OSSD: 'vcmpeq_ossd';
VCMPEQ_OSSS: 'vcmpeq_osss';
VCMPEQ_UQPD: 'vcmpeq_uqpd';
VCMPEQ_UQPS: 'vcmpeq_uqps';
VCMPEQ_UQSD: 'vcmpeq_uqsd';
VCMPEQ_UQSS: 'vcmpeq_uqss';
VCMPEQ_USPD: 'vcmpeq_uspd';
VCMPEQ_USPS: 'vcmpeq_usps';
VCMPEQ_USSD: 'vcmpeq_ussd';
VCMPEQ_USSS: 'vcmpeq_usss';
VCMPEQPD: 'vcmpeqpd';
VCMPEQPS: 'vcmpeqps';
VCMPEQSD: 'vcmpeqsd';
VCMPEQSS: 'vcmpeqss';
VCMPFALSE_OQPD: 'vcmpfalse_oqpd';
VCMPFALSE_OQPS: 'vcmpfalse_oqps';
VCMPFALSE_OQSD: 'vcmpfalse_oqsd';
VCMPFALSE_OQSS: 'vcmpfalse_oqss';
VCMPFALSE_OSPD: 'vcmpfalse_ospd';
VCMPFALSE_OSPS: 'vcmpfalse_osps';
VCMPFALSE_OSSD: 'vcmpfalse_ossd';
VCMPFALSE_OSSS: 'vcmpfalse_osss';
VCMPFALSEPD: 'vcmpfalsepd';
VCMPFALSEPS: 'vcmpfalseps';
VCMPFALSESD: 'vcmpfalsesd';
VCMPFALSESS: 'vcmpfalsess';
VCMPGE_OQPD: 'vcmpge_oqpd';
VCMPGE_OQPS: 'vcmpge_oqps';
VCMPGE_OQSD: 'vcmpge_oqsd';
VCMPGE_OQSS: 'vcmpge_oqss';
VCMPGE_OSPD: 'vcmpge_ospd';
VCMPGE_OSPS: 'vcmpge_osps';
VCMPGE_OSSD: 'vcmpge_ossd';
VCMPGE_OSSS: 'vcmpge_osss';
VCMPGEPD: 'vcmpgepd';
VCMPGEPS: 'vcmpgeps';
VCMPGESD: 'vcmpgesd';
VCMPGESS: 'vcmpgess';
VCMPGT_OQPD: 'vcmpgt_oqpd';
VCMPGT_OQPS: 'vcmpgt_oqps';
VCMPGT_OQSD: 'vcmpgt_oqsd';
VCMPGT_OQSS: 'vcmpgt_oqss';
VCMPGT_OSPD: 'vcmpgt_ospd';
VCMPGT_OSPS: 'vcmpgt_osps';
VCMPGT_OSSD: 'vcmpgt_ossd';
VCMPGT_OSSS: 'vcmpgt_osss';
VCMPGTPD: 'vcmpgtpd';
VCMPGTPS: 'vcmpgtps';
VCMPGTSD: 'vcmpgtsd';
VCMPGTSS: 'vcmpgtss';
VCMPLE_OQPD: 'vcmple_oqpd';
VCMPLE_OQPS: 'vcmple_oqps';
VCMPLE_OQSD: 'vcmple_oqsd';
VCMPLE_OQSS: 'vcmple_oqss';
VCMPLE_OSPD: 'vcmple_ospd';
VCMPLE_OSPS: 'vcmple_osps';
VCMPLE_OSSD: 'vcmple_ossd';
VCMPLE_OSSS: 'vcmple_osss';
VCMPLEPD: 'vcmplepd';
VCMPLEPS: 'vcmpleps';
VCMPLESD: 'vcmplesd';
VCMPLESS: 'vcmpless';
VCMPLT_OQPD: 'vcmplt_oqpd';
VCMPLT_OQPS: 'vcmplt_oqps';
VCMPLT_OQSD: 'vcmplt_oqsd';
VCMPLT_OQSS: 'vcmplt_oqss';
VCMPLT_OSPD: 'vcmplt_ospd';
VCMPLT_OSPS: 'vcmplt_osps';
VCMPLT_OSSD: 'vcmplt_ossd';
VCMPLT_OSSS: 'vcmplt_osss';
VCMPLTPD: 'vcmpltpd';
VCMPLTPS: 'vcmpltps';
VCMPLTSD: 'vcmpltsd';
VCMPLTSS: 'vcmpltss';
VCMPNEQ_OQPD: 'vcmpneq_oqpd';
VCMPNEQ_OQPS: 'vcmpneq_oqps';
VCMPNEQ_OQSD: 'vcmpneq_oqsd';
VCMPNEQ_OQSS: 'vcmpneq_oqss';
VCMPNEQ_OSPD: 'vcmpneq_ospd';
VCMPNEQ_OSPS: 'vcmpneq_osps';
VCMPNEQ_OSSD: 'vcmpneq_ossd';
VCMPNEQ_OSSS: 'vcmpneq_osss';
VCMPNEQ_UQPD: 'vcmpneq_uqpd';
VCMPNEQ_UQPS: 'vcmpneq_uqps';
VCMPNEQ_UQSD: 'vcmpneq_uqsd';
VCMPNEQ_UQSS: 'vcmpneq_uqss';
VCMPNEQ_USPD: 'vcmpneq_uspd';
VCMPNEQ_USPS: 'vcmpneq_usps';
VCMPNEQ_USSD: 'vcmpneq_ussd';
VCMPNEQ_USSS: 'vcmpneq_usss';
VCMPNEQPD: 'vcmpneqpd';
VCMPNEQPS: 'vcmpneqps';
VCMPNEQSD: 'vcmpneqsd';
VCMPNEQSS: 'vcmpneqss';
VCMPNGE_UQPD: 'vcmpnge_uqpd';
VCMPNGE_UQPS: 'vcmpnge_uqps';
VCMPNGE_UQSD: 'vcmpnge_uqsd';
VCMPNGE_UQSS: 'vcmpnge_uqss';
VCMPNGE_USPD: 'vcmpnge_uspd';
VCMPNGE_USPS: 'vcmpnge_usps';
VCMPNGE_USSD: 'vcmpnge_ussd';
VCMPNGE_USSS: 'vcmpnge_usss';
VCMPNGEPD: 'vcmpngepd';
VCMPNGEPS: 'vcmpngeps';
VCMPNGESD: 'vcmpngesd';
VCMPNGESS: 'vcmpngess';
VCMPNGT_UQPD: 'vcmpngt_uqpd';
VCMPNGT_UQPS: 'vcmpngt_uqps';
VCMPNGT_UQSD: 'vcmpngt_uqsd';
VCMPNGT_UQSS: 'vcmpngt_uqss';
VCMPNGT_USPD: 'vcmpngt_uspd';
VCMPNGT_USPS: 'vcmpngt_usps';
VCMPNGT_USSD: 'vcmpngt_ussd';
VCMPNGT_USSS: 'vcmpngt_usss';
VCMPNGTPD: 'vcmpngtpd';
VCMPNGTPS: 'vcmpngtps';
VCMPNGTSD: 'vcmpngtsd';
VCMPNGTSS: 'vcmpngtss';
VCMPNLE_UQPD: 'vcmpnle_uqpd';
VCMPNLE_UQPS: 'vcmpnle_uqps';
VCMPNLE_UQSD: 'vcmpnle_uqsd';
VCMPNLE_UQSS: 'vcmpnle_uqss';
VCMPNLE_USPD: 'vcmpnle_uspd';
VCMPNLE_USPS: 'vcmpnle_usps';
VCMPNLE_USSD: 'vcmpnle_ussd';
VCMPNLE_USSS: 'vcmpnle_usss';
VCMPNLEPD: 'vcmpnlepd';
VCMPNLEPS: 'vcmpnleps';
VCMPNLESD: 'vcmpnlesd';
VCMPNLESS: 'vcmpnless';
VCMPNLT_UQPD: 'vcmpnlt_uqpd';
VCMPNLT_UQPS: 'vcmpnlt_uqps';
VCMPNLT_UQSD: 'vcmpnlt_uqsd';
VCMPNLT_UQSS: 'vcmpnlt_uqss';
VCMPNLT_USPD: 'vcmpnlt_uspd';
VCMPNLT_USPS: 'vcmpnlt_usps';
VCMPNLT_USSD: 'vcmpnlt_ussd';
VCMPNLT_USSS: 'vcmpnlt_usss';
VCMPNLTPD: 'vcmpnltpd';
VCMPNLTPS: 'vcmpnltps';
VCMPNLTSD: 'vcmpnltsd';
VCMPNLTSS: 'vcmpnltss';
VCMPORD_QPD: 'vcmpord_qpd';
VCMPORD_QPS: 'vcmpord_qps';
VCMPORD_QSD: 'vcmpord_qsd';
VCMPORD_QSS: 'vcmpord_qss';
VCMPORD_SPD: 'vcmpord_spd';
VCMPORD_SPS: 'vcmpord_sps';
VCMPORD_SSD: 'vcmpord_ssd';
VCMPORD_SSS: 'vcmpord_sss';
VCMPORDPD: 'vcmpordpd';
VCMPORDPS: 'vcmpordps';
VCMPORDSD: 'vcmpordsd';
VCMPORDSS: 'vcmpordss';
VCMPPD: 'vcmppd';
VCMPPH: 'vcmpph';
VCMPPS: 'vcmpps';
VCMPSD: 'vcmpsd';
VCMPSH: 'vcmpsh';
VCMPSS: 'vcmpss';
VCMPTRUE_UQPD: 'vcmptrue_uqpd';
VCMPTRUE_UQPS: 'vcmptrue_uqps';
VCMPTRUE_UQSD: 'vcmptrue_uqsd';
VCMPTRUE_UQSS: 'vcmptrue_uqss';
VCMPTRUE_USPD: 'vcmptrue_uspd';
VCMPTRUE_USPS: 'vcmptrue_usps';
VCMPTRUE_USSD: 'vcmptrue_ussd';
VCMPTRUE_USSS: 'vcmptrue_usss';
VCMPTRUEPD: 'vcmptruepd';
VCMPTRUEPS: 'vcmptrueps';
VCMPTRUESD: 'vcmptruesd';
VCMPTRUESS: 'vcmptruess';
VCMPUNORD_QPD: 'vcmpunord_qpd';
VCMPUNORD_QPS: 'vcmpunord_qps';
VCMPUNORD_QSD: 'vcmpunord_qsd';
VCMPUNORD_QSS: 'vcmpunord_qss';
VCMPUNORD_SPD: 'vcmpunord_spd';
VCMPUNORD_SPS: 'vcmpunord_sps';
VCMPUNORD_SSD: 'vcmpunord_ssd';
VCMPUNORD_SSS: 'vcmpunord_sss';
VCMPUNORDPD: 'vcmpunordpd';
VCMPUNORDPS: 'vcmpunordps';
VCMPUNORDSD: 'vcmpunordsd';
VCMPUNORDSS: 'vcmpunordss';
VCOMISD: 'vcomisd';
VCOMISH: 'vcomish';
VCOMISS: 'vcomiss';
VCOMPRESSPD: 'vcompresspd';
VCOMPRESSPS: 'vcompressps';
VCVTDQ2PD: 'vcvtdq2pd';
VCVTDQ2PH: 'vcvtdq2ph';
VCVTDQ2PS: 'vcvtdq2ps';
VCVTNE2PS2BF16: 'vcvtne2ps2bf16';
VCVTNEEBF162PS: 'vcvtneebf162ps';
VCVTNEEPH2PS: 'vcvtneeph2ps';
VCVTNEOBF162PS: 'vcvtneobf162ps';
VCVTNEOPH2PS: 'vcvtneoph2ps';
VCVTNEPS2BF16: 'vcvtneps2bf16';
VCVTPD2DQ: 'vcvtpd2dq';
VCVTPD2PH: 'vcvtpd2ph';
VCVTPD2PS: 'vcvtpd2ps';
VCVTPD2QQ: 'vcvtpd2qq';
VCVTPD2UDQ: 'vcvtpd2udq';
VCVTPD2UQQ: 'vcvtpd2uqq';
VCVTPH2DQ: 'vcvtph2dq';
VCVTPH2PD: 'vcvtph2pd';
VCVTPH2PS: 'vcvtph2ps';
VCVTPH2PSX: 'vcvtph2psx';
VCVTPH2QQ: 'vcvtph2qq';
VCVTPH2UDQ: 'vcvtph2udq';
VCVTPH2UQQ: 'vcvtph2uqq';
VCVTPH2UW: 'vcvtph2uw';
VCVTPH2W: 'vcvtph2w';
VCVTPS2DQ: 'vcvtps2dq';
VCVTPS2PD: 'vcvtps2pd';
VCVTPS2PH: 'vcvtps2ph';
VCVTPS2QQ: 'vcvtps2qq';
VCVTPS2UDQ: 'vcvtps2udq';
VCVTPS2UQQ: 'vcvtps2uqq';
VCVTQQ2PD: 'vcvtqq2pd';
VCVTQQ2PH: 'vcvtqq2ph';
VCVTQQ2PS: 'vcvtqq2ps';
VCVTSD2SH: 'vcvtsd2sh';
VCVTSD2SI: 'vcvtsd2si';
VCVTSD2SS: 'vcvtsd2ss';
VCVTSD2USI: 'vcvtsd2usi';
VCVTSH2SD: 'vcvtsh2sd';
VCVTSH2SI: 'vcvtsh2si';
VCVTSH2SS: 'vcvtsh2ss';
VCVTSH2USI: 'vcvtsh2usi';
VCVTSI2SD: 'vcvtsi2sd';
VCVTSI2SH: 'vcvtsi2sh';
VCVTSI2SS: 'vcvtsi2ss';
VCVTSS2SD: 'vcvtss2sd';
VCVTSS2SH: 'vcvtss2sh';
VCVTSS2SI: 'vcvtss2si';
VCVTSS2USI: 'vcvtss2usi';
VCVTTPD2DQ: 'vcvttpd2dq';
VCVTTPD2QQ: 'vcvttpd2qq';
VCVTTPD2UDQ: 'vcvttpd2udq';
VCVTTPD2UQQ: 'vcvttpd2uqq';
VCVTTPH2DQ: 'vcvttph2dq';
VCVTTPH2QQ: 'vcvttph2qq';
VCVTTPH2UDQ: 'vcvttph2udq';
VCVTTPH2UQQ: 'vcvttph2uqq';
VCVTTPH2UW: 'vcvttph2uw';
VCVTTPH2W: 'vcvttph2w';
VCVTTPS2DQ: 'vcvttps2dq';
VCVTTPS2QQ: 'vcvttps2qq';
VCVTTPS2UDQ: 'vcvttps2udq';
VCVTTPS2UQQ: 'vcvttps2uqq';
VCVTTSD2SI: 'vcvttsd2si';
VCVTTSD2USI: 'vcvttsd2usi';
VCVTTSH2SI: 'vcvttsh2si';
VCVTTSH2USI: 'vcvttsh2usi';
VCVTTSS2SI: 'vcvttss2si';
VCVTTSS2USI: 'vcvttss2usi';
VCVTUDQ2PD: 'vcvtudq2pd';
VCVTUDQ2PH: 'vcvtudq2ph';
VCVTUDQ2PS: 'vcvtudq2ps';
VCVTUQQ2PD: 'vcvtuqq2pd';
VCVTUQQ2PH: 'vcvtuqq2ph';
VCVTUQQ2PS: 'vcvtuqq2ps';
VCVTUSI2SD: 'vcvtusi2sd';
VCVTUSI2SH: 'vcvtusi2sh';
VCVTUSI2SS: 'vcvtusi2ss';
VCVTUW2PH: 'vcvtuw2ph';
VCVTW2PH: 'vcvtw2ph';
VDBPSADBW: 'vdbpsadbw';
VDIVPD: 'vdivpd';
VDIVPH: 'vdivph';
VDIVPS: 'vdivps';
VDIVSD: 'vdivsd';
VDIVSH: 'vdivsh';
VDIVSS: 'vdivss';
VDPBF16PS: 'vdpbf16ps';
VDPPD: 'vdppd';
VDPPS: 'vdpps';
VENDSCALEPH: 'vendscaleph';
VENDSCALESH: 'vendscalesh';
VEXP2PD: 'vexp2pd';
VEXP2PS: 'vexp2ps';
VEXPANDPD: 'vexpandpd';
VEXPANDPS: 'vexpandps';
VEXTRACTF128: 'vextractf128';
VEXTRACTF32X4: 'vextractf32x4';
VEXTRACTF32X8: 'vextractf32x8';
VEXTRACTF64X2: 'vextractf64x2';
VEXTRACTF64X4: 'vextractf64x4';
VEXTRACTI128: 'vextracti128';
VEXTRACTI32X4: 'vextracti32x4';
VEXTRACTI32X8: 'vextracti32x8';
VEXTRACTI64X2: 'vextracti64x2';
VEXTRACTI64X4: 'vextracti64x4';
VEXTRACTPS: 'vextractps';
VFCMADDCPH: 'vfcmaddcph';
VFCMADDCSH: 'vfcmaddcsh';
VFCMULCPCH: 'vfcmulcpch';
VFCMULCSH: 'vfcmulcsh';
VFIXUPIMMPD: 'vfixupimmpd';
VFIXUPIMMPS: 'vfixupimmps';
VFIXUPIMMSD: 'vfixupimmsd';
VFIXUPIMMSS: 'vfixupimmss';
VFMADD123PD: 'vfmadd123pd';
VFMADD123PS: 'vfmadd123ps';
VFMADD123SD: 'vfmadd123sd';
VFMADD123SS: 'vfmadd123ss';
VFMADD132PD: 'vfmadd132pd';
VFMADD132PH: 'vfmadd132ph';
VFMADD132PS: 'vfmadd132ps';
VFMADD132SD: 'vfmadd132sd';
VFMADD132SS: 'vfmadd132ss';
VFMADD213PD: 'vfmadd213pd';
VFMADD213PH: 'vfmadd213ph';
VFMADD213PS: 'vfmadd213ps';
VFMADD213SD: 'vfmadd213sd';
VFMADD213SS: 'vfmadd213ss';
VFMADD231PD: 'vfmadd231pd';
VFMADD231PH: 'vfmadd231ph';
VFMADD231PS: 'vfmadd231ps';
VFMADD231SD: 'vfmadd231sd';
VFMADD231SS: 'vfmadd231ss';
VFMADD312PD: 'vfmadd312pd';
VFMADD312PS: 'vfmadd312ps';
VFMADD312SD: 'vfmadd312sd';
VFMADD312SS: 'vfmadd312ss';
VFMADD321PD: 'vfmadd321pd';
VFMADD321PS: 'vfmadd321ps';
VFMADD321SD: 'vfmadd321sd';
VFMADD321SS: 'vfmadd321ss';
VFMADDCPH: 'vfmaddcph';
VFMADDCSH: 'vfmaddcsh';
VFMADDPD: 'vfmaddpd';
VFMADDPS: 'vfmaddps';
VFMADDSD: 'vfmaddsd';
VFMADDSS: 'vfmaddss';
VFMADDSUB123PD: 'vfmaddsub123pd';
VFMADDSUB123PS: 'vfmaddsub123ps';
VFMADDSUB132PD: 'vfmaddsub132pd';
VFMADDSUB132PH: 'vfmaddsub132ph';
VFMADDSUB132PS: 'vfmaddsub132ps';
VFMADDSUB213PD: 'vfmaddsub213pd';
VFMADDSUB213PH: 'vfmaddsub213ph';
VFMADDSUB213PS: 'vfmaddsub213ps';
VFMADDSUB231PD: 'vfmaddsub231pd';
VFMADDSUB231PH: 'vfmaddsub231ph';
VFMADDSUB231PS: 'vfmaddsub231ps';
VFMADDSUB312PD: 'vfmaddsub312pd';
VFMADDSUB312PS: 'vfmaddsub312ps';
VFMADDSUB321PD: 'vfmaddsub321pd';
VFMADDSUB321PS: 'vfmaddsub321ps';
VFMADDSUBPD: 'vfmaddsubpd';
VFMADDSUBPS: 'vfmaddsubps';
VFMSUB123PD: 'vfmsub123pd';
VFMSUB123PS: 'vfmsub123ps';
VFMSUB123SD: 'vfmsub123sd';
VFMSUB123SS: 'vfmsub123ss';
VFMSUB132PD: 'vfmsub132pd';
VFMSUB132PH: 'vfmsub132ph';
VFMSUB132PS: 'vfmsub132ps';
VFMSUB132SD: 'vfmsub132sd';
VFMSUB132SS: 'vfmsub132ss';
VFMSUB213PD: 'vfmsub213pd';
VFMSUB213PH: 'vfmsub213ph';
VFMSUB213PS: 'vfmsub213ps';
VFMSUB213SD: 'vfmsub213sd';
VFMSUB213SS: 'vfmsub213ss';
VFMSUB231PD: 'vfmsub231pd';
VFMSUB231PH: 'vfmsub231ph';
VFMSUB231PS: 'vfmsub231ps';
VFMSUB231SD: 'vfmsub231sd';
VFMSUB231SS: 'vfmsub231ss';
VFMSUB312PD: 'vfmsub312pd';
VFMSUB312PS: 'vfmsub312ps';
VFMSUB312SD: 'vfmsub312sd';
VFMSUB312SS: 'vfmsub312ss';
VFMSUB321PD: 'vfmsub321pd';
VFMSUB321PS: 'vfmsub321ps';
VFMSUB321SD: 'vfmsub321sd';
VFMSUB321SS: 'vfmsub321ss';
VFMSUBADD123PD: 'vfmsubadd123pd';
VFMSUBADD123PS: 'vfmsubadd123ps';
VFMSUBADD132PD: 'vfmsubadd132pd';
VFMSUBADD132PH: 'vfmsubadd132ph';
VFMSUBADD132PS: 'vfmsubadd132ps';
VFMSUBADD213PD: 'vfmsubadd213pd';
VFMSUBADD213PH: 'vfmsubadd213ph';
VFMSUBADD213PS: 'vfmsubadd213ps';
VFMSUBADD231PD: 'vfmsubadd231pd';
VFMSUBADD231PH: 'vfmsubadd231ph';
VFMSUBADD231PS: 'vfmsubadd231ps';
VFMSUBADD312PD: 'vfmsubadd312pd';
VFMSUBADD312PS: 'vfmsubadd312ps';
VFMSUBADD321PD: 'vfmsubadd321pd';
VFMSUBADD321PS: 'vfmsubadd321ps';
VFMSUBADDPD: 'vfmsubaddpd';
VFMSUBADDPS: 'vfmsubaddps';
VFMSUBPD: 'vfmsubpd';
VFMSUBPS: 'vfmsubps';
VFMSUBSD: 'vfmsubsd';
VFMSUBSS: 'vfmsubss';
VFMULCPCH: 'vfmulcpch';
VFMULCSH: 'vfmulcsh';
VFNMADD123PD: 'vfnmadd123pd';
VFNMADD123PS: 'vfnmadd123ps';
VFNMADD123SD: 'vfnmadd123sd';
VFNMADD123SS: 'vfnmadd123ss';
VFNMADD132PD: 'vfnmadd132pd';
VFNMADD132PS: 'vfnmadd132ps';
VFNMADD132SD: 'vfnmadd132sd';
VFNMADD132SS: 'vfnmadd132ss';
VFNMADD213PD: 'vfnmadd213pd';
VFNMADD213PS: 'vfnmadd213ps';
VFNMADD213SD: 'vfnmadd213sd';
VFNMADD213SS: 'vfnmadd213ss';
VFNMADD231PD: 'vfnmadd231pd';
VFNMADD231PS: 'vfnmadd231ps';
VFNMADD231SD: 'vfnmadd231sd';
VFNMADD231SS: 'vfnmadd231ss';
VFNMADD312PD: 'vfnmadd312pd';
VFNMADD312PS: 'vfnmadd312ps';
VFNMADD312SD: 'vfnmadd312sd';
VFNMADD312SS: 'vfnmadd312ss';
VFNMADD321PD: 'vfnmadd321pd';
VFNMADD321PS: 'vfnmadd321ps';
VFNMADD321SD: 'vfnmadd321sd';
VFNMADD321SS: 'vfnmadd321ss';
VFNMADDPD: 'vfnmaddpd';
VFNMADDPS: 'vfnmaddps';
VFNMADDSD: 'vfnmaddsd';
VFNMADDSS: 'vfnmaddss';
VFNMSUB123PD: 'vfnmsub123pd';
VFNMSUB123PS: 'vfnmsub123ps';
VFNMSUB123SD: 'vfnmsub123sd';
VFNMSUB123SS: 'vfnmsub123ss';
VFNMSUB132PD: 'vfnmsub132pd';
VFNMSUB132PS: 'vfnmsub132ps';
VFNMSUB132SD: 'vfnmsub132sd';
VFNMSUB132SS: 'vfnmsub132ss';
VFNMSUB213PD: 'vfnmsub213pd';
VFNMSUB213PS: 'vfnmsub213ps';
VFNMSUB213SD: 'vfnmsub213sd';
VFNMSUB213SS: 'vfnmsub213ss';
VFNMSUB231PD: 'vfnmsub231pd';
VFNMSUB231PS: 'vfnmsub231ps';
VFNMSUB231SD: 'vfnmsub231sd';
VFNMSUB231SS: 'vfnmsub231ss';
VFNMSUB312PD: 'vfnmsub312pd';
VFNMSUB312PS: 'vfnmsub312ps';
VFNMSUB312SD: 'vfnmsub312sd';
VFNMSUB312SS: 'vfnmsub312ss';
VFNMSUB321PD: 'vfnmsub321pd';
VFNMSUB321PS: 'vfnmsub321ps';
VFNMSUB321SD: 'vfnmsub321sd';
VFNMSUB321SS: 'vfnmsub321ss';
VFNMSUBPD: 'vfnmsubpd';
VFNMSUBPS: 'vfnmsubps';
VFNMSUBSD: 'vfnmsubsd';
VFNMSUBSS: 'vfnmsubss';
VFPCLASSPD: 'vfpclasspd';
VFPCLASSPH: 'vfpclassph';
VFPCLASSPS: 'vfpclassps';
VFPCLASSSD: 'vfpclasssd';
VFPCLASSSH: 'vfpclasssh';
VFPCLASSSS: 'vfpclassss';
VFRCZPD: 'vfrczpd';
VFRCZPS: 'vfrczps';
VFRCZSD: 'vfrczsd';
VFRCZSS: 'vfrczss';
VGATHERDPD: 'vgatherdpd';
VGATHERDPS: 'vgatherdps';
VGATHERPF0DPD: 'vgatherpf0dpd';
VGATHERPF0DPS: 'vgatherpf0dps';
VGATHERPF0QPD: 'vgatherpf0qpd';
VGATHERPF0QPS: 'vgatherpf0qps';
VGATHERPF1DPD: 'vgatherpf1dpd';
VGATHERPF1DPS: 'vgatherpf1dps';
VGATHERPF1QPD: 'vgatherpf1qpd';
VGATHERPF1QPS: 'vgatherpf1qps';
VGATHERQPD: 'vgatherqpd';
VGATHERQPS: 'vgatherqps';
VGETEXPPD: 'vgetexppd';
VGETEXPPH: 'vgetexpph';
VGETEXPPS: 'vgetexpps';
VGETEXPSD: 'vgetexpsd';
VGETEXPSH: 'vgetexpsh';
VGETEXPSS: 'vgetexpss';
VGETMANTPD: 'vgetmantpd';
VGETMANTPH: 'vgetmantph';
VGETMANTPS: 'vgetmantps';
VGETMANTSD: 'vgetmantsd';
VGETMANTSH: 'vgetmantsh';
VGETMANTSS: 'vgetmantss';
VGETMAXPH: 'vgetmaxph';
VGETMAXSH: 'vgetmaxsh';
VGETMINPH: 'vgetminph';
VGETMINSH: 'vgetminsh';
VGF2P8AFFINEINVQB: 'vgf2p8affineinvqb';
VGF2P8AFFINEQB: 'vgf2p8affineqb';
VGF2P8MULB: 'vgf2p8mulb';
VHADDPD: 'vhaddpd';
VHADDPS: 'vhaddps';
VHSUBPD: 'vhsubpd';
VHSUBPS: 'vhsubps';
VINSERTF128: 'vinsertf128';
VINSERTF32X4: 'vinsertf32x4';
VINSERTF32X8: 'vinsertf32x8';
VINSERTF64X2: 'vinsertf64x2';
VINSERTF64X4: 'vinsertf64x4';
VINSERTI128: 'vinserti128';
VINSERTI32X4: 'vinserti32x4';
VINSERTI32X8: 'vinserti32x8';
VINSERTI64X2: 'vinserti64x2';
VINSERTI64X4: 'vinserti64x4';
VINSERTPS: 'vinsertps';
VLDDQU: 'vlddqu';
VLDMXCSR: 'vldmxcsr';
VLDQQU: 'vldqqu';
VMASKMOVDQU: 'vmaskmovdqu';
VMASKMOVPD: 'vmaskmovpd';
VMASKMOVPS: 'vmaskmovps';
VMAXPD: 'vmaxpd';
VMAXPS: 'vmaxps';
VMAXSD: 'vmaxsd';
VMAXSS: 'vmaxss';
VMCALL: 'vmcall';
VMCLEAR: 'vmclear';
VMFUNC: 'vmfunc';
VMGEXIT: 'vmgexit';
VMINPD: 'vminpd';
VMINPS: 'vminps';
VMINSD: 'vminsd';
VMINSS: 'vminss';
VMLAUNCH: 'vmlaunch';
VMLOAD: 'vmload';
VMMCALL: 'vmmcall';
VMOVAPD: 'vmovapd';
VMOVAPS: 'vmovaps';
VMOVD: 'vmovd';
VMOVDDUP: 'vmovddup';
VMOVDQA: 'vmovdqa';
VMOVDQA32: 'vmovdqa32';
VMOVDQA64: 'vmovdqa64';
VMOVDQU: 'vmovdqu';
VMOVDQU16: 'vmovdqu16';
VMOVDQU32: 'vmovdqu32';
VMOVDQU64: 'vmovdqu64';
VMOVDQU8: 'vmovdqu8';
VMOVHLPS: 'vmovhlps';
VMOVHPD: 'vmovhpd';
VMOVHPS: 'vmovhps';
VMOVLHPS: 'vmovlhps';
VMOVLPD: 'vmovlpd';
VMOVLPS: 'vmovlps';
VMOVMSKPD: 'vmovmskpd';
VMOVMSKPS: 'vmovmskps';
VMOVNTDQ: 'vmovntdq';
VMOVNTDQA: 'vmovntdqa';
VMOVNTPD: 'vmovntpd';
VMOVNTPS: 'vmovntps';
VMOVNTQQ: 'vmovntqq';
VMOVQ: 'vmovq';
VMOVQQA: 'vmovqqa';
VMOVQQU: 'vmovqqu';
VMOVSD: 'vmovsd';
VMOVSH: 'vmovsh';
VMOVSHDUP: 'vmovshdup';
VMOVSLDUP: 'vmovsldup';
VMOVSS: 'vmovss';
VMOVUPD: 'vmovupd';
VMOVUPS: 'vmovups';
VMOVW: 'vmovw';
VMPSADBW: 'vmpsadbw';
VMPTRLD: 'vmptrld';
VMPTRST: 'vmptrst';
VMREAD: 'vmread';
VMRESUME: 'vmresume';
VMRUN: 'vmrun';
VMSAVE: 'vmsave';
VMULPD: 'vmulpd';
VMULPH: 'vmulph';
VMULPS: 'vmulps';
VMULSD: 'vmulsd';
VMULSH: 'vmulsh';
VMULSS: 'vmulss';
VMWRITE: 'vmwrite';
VMXOFF: 'vmxoff';
VMXON: 'vmxon';
VORPD: 'vorpd';
VORPS: 'vorps';
VP2INTERSECTD: 'vp2intersectd';
VPABSB: 'vpabsb';
VPABSD: 'vpabsd';
VPABSQ: 'vpabsq';
VPABSW: 'vpabsw';
VPACKSSDW: 'vpackssdw';
VPACKSSWB: 'vpacksswb';
VPACKUSDW: 'vpackusdw';
VPACKUSWB: 'vpackuswb';
VPADDB: 'vpaddb';
VPADDD: 'vpaddd';
VPADDQ: 'vpaddq';
VPADDSB: 'vpaddsb';
VPADDSW: 'vpaddsw';
VPADDUSB: 'vpaddusb';
VPADDUSW: 'vpaddusw';
VPADDW: 'vpaddw';
VPALIGNR: 'vpalignr';
VPAND: 'vpand';
VPANDD: 'vpandd';
VPANDN: 'vpandn';
VPANDND: 'vpandnd';
VPANDNQ: 'vpandnq';
VPANDQ: 'vpandq';
VPAVGB: 'vpavgb';
VPAVGW: 'vpavgw';
VPBLENDD: 'vpblendd';
VPBLENDMB: 'vpblendmb';
VPBLENDMD: 'vpblendmd';
VPBLENDMQ: 'vpblendmq';
VPBLENDMW: 'vpblendmw';
VPBLENDVB: 'vpblendvb';
VPBLENDW: 'vpblendw';
VPBROADCASTB: 'vpbroadcastb';
VPBROADCASTD: 'vpbroadcastd';
VPBROADCASTMB2Q: 'vpbroadcastmb2q';
VPBROADCASTMW2D: 'vpbroadcastmw2d';
VPBROADCASTQ: 'vpbroadcastq';
VPBROADCASTW: 'vpbroadcastw';
VPCLMULHQHQDQ: 'vpclmulhqhqdq';
VPCLMULHQLQDQ: 'vpclmulhqlqdq';
VPCLMULLQHQDQ: 'vpclmullqhqdq';
VPCLMULLQLQDQ: 'vpclmullqlqdq';
VPCLMULQDQ: 'vpclmulqdq';
VPCMOV: 'vpcmov';
VPCMPB: 'vpcmpb';
VPCMPD: 'vpcmpd';
VPCMPEQB: 'vpcmpeqb';
VPCMPEQD: 'vpcmpeqd';
VPCMPEQQ: 'vpcmpeqq';
VPCMPEQUB: 'vpcmpequb';
VPCMPEQUD: 'vpcmpequd';
VPCMPEQUQ: 'vpcmpequq';
VPCMPEQUW: 'vpcmpequw';
VPCMPEQW: 'vpcmpeqw';
VPCMPESTRI: 'vpcmpestri';
VPCMPESTRM: 'vpcmpestrm';
VPCMPGEB: 'vpcmpgeb';
VPCMPGED: 'vpcmpged';
VPCMPGEQ: 'vpcmpgeq';
VPCMPGEUB: 'vpcmpgeub';
VPCMPGEUD: 'vpcmpgeud';
VPCMPGEUQ: 'vpcmpgeuq';
VPCMPGEUW: 'vpcmpgeuw';
VPCMPGEW: 'vpcmpgew';
VPCMPGTB: 'vpcmpgtb';
VPCMPGTD: 'vpcmpgtd';
VPCMPGTQ: 'vpcmpgtq';
VPCMPGTUB: 'vpcmpgtub';
VPCMPGTUD: 'vpcmpgtud';
VPCMPGTUQ: 'vpcmpgtuq';
VPCMPGTUW: 'vpcmpgtuw';
VPCMPGTW: 'vpcmpgtw';
VPCMPISTRI: 'vpcmpistri';
VPCMPISTRM: 'vpcmpistrm';
VPCMPLEB: 'vpcmpleb';
VPCMPLED: 'vpcmpled';
VPCMPLEQ: 'vpcmpleq';
VPCMPLEUB: 'vpcmpleub';
VPCMPLEUD: 'vpcmpleud';
VPCMPLEUQ: 'vpcmpleuq';
VPCMPLEUW: 'vpcmpleuw';
VPCMPLEW: 'vpcmplew';
VPCMPLTB: 'vpcmpltb';
VPCMPLTD: 'vpcmpltd';
VPCMPLTQ: 'vpcmpltq';
VPCMPLTUB: 'vpcmpltub';
VPCMPLTUD: 'vpcmpltud';
VPCMPLTUQ: 'vpcmpltuq';
VPCMPLTUW: 'vpcmpltuw';
VPCMPLTW: 'vpcmpltw';
VPCMPNEQB: 'vpcmpneqb';
VPCMPNEQD: 'vpcmpneqd';
VPCMPNEQQ: 'vpcmpneqq';
VPCMPNEQUB: 'vpcmpnequb';
VPCMPNEQUD: 'vpcmpnequd';
VPCMPNEQUQ: 'vpcmpnequq';
VPCMPNEQUW: 'vpcmpnequw';
VPCMPNEQW: 'vpcmpneqw';
VPCMPNGTB: 'vpcmpngtb';
VPCMPNGTD: 'vpcmpngtd';
VPCMPNGTQ: 'vpcmpngtq';
VPCMPNGTUB: 'vpcmpngtub';
VPCMPNGTUD: 'vpcmpngtud';
VPCMPNGTUQ: 'vpcmpngtuq';
VPCMPNGTUW: 'vpcmpngtuw';
VPCMPNGTW: 'vpcmpngtw';
VPCMPNLEB: 'vpcmpnleb';
VPCMPNLED: 'vpcmpnled';
VPCMPNLEQ: 'vpcmpnleq';
VPCMPNLEUB: 'vpcmpnleub';
VPCMPNLEUD: 'vpcmpnleud';
VPCMPNLEUQ: 'vpcmpnleuq';
VPCMPNLEUW: 'vpcmpnleuw';
VPCMPNLEW: 'vpcmpnlew';
VPCMPNLTB: 'vpcmpnltb';
VPCMPNLTD: 'vpcmpnltd';
VPCMPNLTQ: 'vpcmpnltq';
VPCMPNLTUB: 'vpcmpnltub';
VPCMPNLTUD: 'vpcmpnltud';
VPCMPNLTUQ: 'vpcmpnltuq';
VPCMPNLTUW: 'vpcmpnltuw';
VPCMPNLTW: 'vpcmpnltw';
VPCMPQ: 'vpcmpq';
VPCMPUB: 'vpcmpub';
VPCMPUD: 'vpcmpud';
VPCMPUQ: 'vpcmpuq';
VPCMPUW: 'vpcmpuw';
VPCMPW: 'vpcmpw';
VPCOMB: 'vpcomb';
VPCOMD: 'vpcomd';
VPCOMPRESSB: 'vpcompressb';
VPCOMPRESSD: 'vpcompressd';
VPCOMPRESSQ: 'vpcompressq';
VPCOMPRESSW: 'vpcompressw';
VPCOMQ: 'vpcomq';
VPCOMUB: 'vpcomub';
VPCOMUD: 'vpcomud';
VPCOMUQ: 'vpcomuq';
VPCOMUW: 'vpcomuw';
VPCOMW: 'vpcomw';
VPCONFLICTD: 'vpconflictd';
VPCONFLICTQ: 'vpconflictq';
VPDPBSSD: 'vpdpbssd';
VPDPBSSDS: 'vpdpbssds';
VPDPBSUD: 'vpdpbsud';
VPDPBSUDS: 'vpdpbsuds';
VPDPBUSD: 'vpdpbusd';
VPDPBUSDS: 'vpdpbusds';
VPDPBUUD: 'vpdpbuud';
VPDPBUUDS: 'vpdpbuuds';
VPDPWSSD: 'vpdpwssd';
VPDPWSSDS: 'vpdpwssds';
VPERM2F128: 'vperm2f128';
VPERM2I128: 'vperm2i128';
VPERMB: 'vpermb';
VPERMD: 'vpermd';
VPERMI2B: 'vpermi2b';
VPERMI2D: 'vpermi2d';
VPERMI2PD: 'vpermi2pd';
VPERMI2PS: 'vpermi2ps';
VPERMI2Q: 'vpermi2q';
VPERMI2W: 'vpermi2w';
VPERMILPD: 'vpermilpd';
VPERMILPS: 'vpermilps';
VPERMPD: 'vpermpd';
VPERMPS: 'vpermps';
VPERMQ: 'vpermq';
VPERMT2B: 'vpermt2b';
VPERMT2D: 'vpermt2d';
VPERMT2PD: 'vpermt2pd';
VPERMT2PS: 'vpermt2ps';
VPERMT2Q: 'vpermt2q';
VPERMT2W: 'vpermt2w';
VPERMW: 'vpermw';
VPEXPANDB: 'vpexpandb';
VPEXPANDD: 'vpexpandd';
VPEXPANDQ: 'vpexpandq';
VPEXPANDW: 'vpexpandw';
VPEXTRB: 'vpextrb';
VPEXTRD: 'vpextrd';
VPEXTRQ: 'vpextrq';
VPEXTRW: 'vpextrw';
VPGATHERDD: 'vpgatherdd';
VPGATHERDQ: 'vpgatherdq';
VPGATHERQD: 'vpgatherqd';
VPGATHERQQ: 'vpgatherqq';
VPHADDBD: 'vphaddbd';
VPHADDBQ: 'vphaddbq';
VPHADDBW: 'vphaddbw';
VPHADDD: 'vphaddd';
VPHADDDQ: 'vphadddq';
VPHADDSW: 'vphaddsw';
VPHADDUBD: 'vphaddubd';
VPHADDUBQ: 'vphaddubq';
VPHADDUBW: 'vphaddubw';
VPHADDUDQ: 'vphaddudq';
VPHADDUWD: 'vphadduwd';
VPHADDUWQ: 'vphadduwq';
VPHADDW: 'vphaddw';
VPHADDWD: 'vphaddwd';
VPHADDWQ: 'vphaddwq';
VPHMINPOSUW: 'vphminposuw';
VPHSUBBW: 'vphsubbw';
VPHSUBD: 'vphsubd';
VPHSUBDQ: 'vphsubdq';
VPHSUBSW: 'vphsubsw';
VPHSUBW: 'vphsubw';
VPHSUBWD: 'vphsubwd';
VPINSRB: 'vpinsrb';
VPINSRD: 'vpinsrd';
VPINSRQ: 'vpinsrq';
VPINSRW: 'vpinsrw';
VPLZCNTD: 'vplzcntd';
VPLZCNTQ: 'vplzcntq';
VPMACSDD: 'vpmacsdd';
VPMACSDQH: 'vpmacsdqh';
VPMACSDQL: 'vpmacsdql';
VPMACSSDD: 'vpmacssdd';
VPMACSSDQH: 'vpmacssdqh';
VPMACSSDQL: 'vpmacssdql';
VPMACSSWD: 'vpmacsswd';
VPMACSSWW: 'vpmacssww';
VPMACSWD: 'vpmacswd';
VPMACSWW: 'vpmacsww';
VPMADCSSWD: 'vpmadcsswd';
VPMADCSWD: 'vpmadcswd';
VPMADD132PH: 'vpmadd132ph';
VPMADD132SH: 'vpmadd132sh';
VPMADD213PH: 'vpmadd213ph';
VPMADD213SH: 'vpmadd213sh';
VPMADD231PH: 'vpmadd231ph';
VPMADD231SH: 'vpmadd231sh';
VPMADD52HUQ: 'vpmadd52huq';
VPMADD52LUQ: 'vpmadd52luq';
VPMADDUBSW: 'vpmaddubsw';
VPMADDWD: 'vpmaddwd';
VPMASKMOVD: 'vpmaskmovd';
VPMASKMOVQ: 'vpmaskmovq';
VPMAXSB: 'vpmaxsb';
VPMAXSD: 'vpmaxsd';
VPMAXSQ: 'vpmaxsq';
VPMAXSW: 'vpmaxsw';
VPMAXUB: 'vpmaxub';
VPMAXUD: 'vpmaxud';
VPMAXUQ: 'vpmaxuq';
VPMAXUW: 'vpmaxuw';
VPMINSB: 'vpminsb';
VPMINSD: 'vpminsd';
VPMINSQ: 'vpminsq';
VPMINSW: 'vpminsw';
VPMINUB: 'vpminub';
VPMINUD: 'vpminud';
VPMINUQ: 'vpminuq';
VPMINUW: 'vpminuw';
VPMOVB2M: 'vpmovb2m';
VPMOVD2M: 'vpmovd2m';
VPMOVDB: 'vpmovdb';
VPMOVDW: 'vpmovdw';
VPMOVM2B: 'vpmovm2b';
VPMOVM2D: 'vpmovm2d';
VPMOVM2Q: 'vpmovm2q';
VPMOVM2W: 'vpmovm2w';
VPMOVMSKB: 'vpmovmskb';
VPMOVQ2M: 'vpmovq2m';
VPMOVQB: 'vpmovqb';
VPMOVQD: 'vpmovqd';
VPMOVQW: 'vpmovqw';
VPMOVSDB: 'vpmovsdb';
VPMOVSDW: 'vpmovsdw';
VPMOVSQB: 'vpmovsqb';
VPMOVSQD: 'vpmovsqd';
VPMOVSQW: 'vpmovsqw';
VPMOVSWB: 'vpmovswb';
VPMOVSXBD: 'vpmovsxbd';
VPMOVSXBQ: 'vpmovsxbq';
VPMOVSXBW: 'vpmovsxbw';
VPMOVSXDQ: 'vpmovsxdq';
VPMOVSXWD: 'vpmovsxwd';
VPMOVSXWQ: 'vpmovsxwq';
VPMOVUSDB: 'vpmovusdb';
VPMOVUSDW: 'vpmovusdw';
VPMOVUSQB: 'vpmovusqb';
VPMOVUSQD: 'vpmovusqd';
VPMOVUSQW: 'vpmovusqw';
VPMOVUSWB: 'vpmovuswb';
VPMOVW2M: 'vpmovw2m';
VPMOVWB: 'vpmovwb';
VPMOVZXBD: 'vpmovzxbd';
VPMOVZXBQ: 'vpmovzxbq';
VPMOVZXBW: 'vpmovzxbw';
VPMOVZXDQ: 'vpmovzxdq';
VPMOVZXWD: 'vpmovzxwd';
VPMOVZXWQ: 'vpmovzxwq';
VPMSUB132PH: 'vpmsub132ph';
VPMSUB132SH: 'vpmsub132sh';
VPMSUB213PH: 'vpmsub213ph';
VPMSUB213SH: 'vpmsub213sh';
VPMSUB231PH: 'vpmsub231ph';
VPMSUB231SH: 'vpmsub231sh';
VPMULDQ: 'vpmuldq';
VPMULHRSW: 'vpmulhrsw';
VPMULHUW: 'vpmulhuw';
VPMULHW: 'vpmulhw';
VPMULLD: 'vpmulld';
VPMULLQ: 'vpmullq';
VPMULLW: 'vpmullw';
VPMULTISHIFTQB: 'vpmultishiftqb';
VPMULUDQ: 'vpmuludq';
VPNMADD132SH: 'vpnmadd132sh';
VPNMADD213SH: 'vpnmadd213sh';
VPNMADD231SH: 'vpnmadd231sh';
VPNMSUB132SH: 'vpnmsub132sh';
VPNMSUB213SH: 'vpnmsub213sh';
VPNMSUB231SH: 'vpnmsub231sh';
VPOPCNTB: 'vpopcntb';
VPOPCNTD: 'vpopcntd';
VPOPCNTQ: 'vpopcntq';
VPOPCNTW: 'vpopcntw';
VPOR: 'vpor';
VPORD: 'vpord';
VPORQ: 'vporq';
VPPERM: 'vpperm';
VPROLD: 'vprold';
VPROLQ: 'vprolq';
VPROLVD: 'vprolvd';
VPROLVQ: 'vprolvq';
VPRORD: 'vprord';
VPRORQ: 'vprorq';
VPRORVD: 'vprorvd';
VPRORVQ: 'vprorvq';
VPROTB: 'vprotb';
VPROTD: 'vprotd';
VPROTQ: 'vprotq';
VPROTW: 'vprotw';
VPSADBW: 'vpsadbw';
VPSCATTERDD: 'vpscatterdd';
VPSCATTERDQ: 'vpscatterdq';
VPSCATTERQD: 'vpscatterqd';
VPSCATTERQQ: 'vpscatterqq';
VPSHAB: 'vpshab';
VPSHAD: 'vpshad';
VPSHAQ: 'vpshaq';
VPSHAW: 'vpshaw';
VPSHLB: 'vpshlb';
VPSHLD: 'vpshld';
VPSHLDD: 'vpshldd';
VPSHLDQ: 'vpshldq';
VPSHLDVD: 'vpshldvd';
VPSHLDVQ: 'vpshldvq';
VPSHLDVW: 'vpshldvw';
VPSHLDW: 'vpshldw';
VPSHLQ: 'vpshlq';
VPSHLW: 'vpshlw';
VPSHRDD: 'vpshrdd';
VPSHRDQ: 'vpshrdq';
VPSHRDVD: 'vpshrdvd';
VPSHRDVQ: 'vpshrdvq';
VPSHRDVW: 'vpshrdvw';
VPSHRDW: 'vpshrdw';
VPSHUFB: 'vpshufb';
VPSHUFBITQMB: 'vpshufbitqmb';
VPSHUFD: 'vpshufd';
VPSHUFHW: 'vpshufhw';
VPSHUFLW: 'vpshuflw';
VPSIGNB: 'vpsignb';
VPSIGND: 'vpsignd';
VPSIGNW: 'vpsignw';
VPSLLD: 'vpslld';
VPSLLDQ: 'vpslldq';
VPSLLQ: 'vpsllq';
VPSLLVD: 'vpsllvd';
VPSLLVQ: 'vpsllvq';
VPSLLVW: 'vpsllvw';
VPSLLW: 'vpsllw';
VPSRAD: 'vpsrad';
VPSRAQ: 'vpsraq';
VPSRAVD: 'vpsravd';
VPSRAVQ: 'vpsravq';
VPSRAVW: 'vpsravw';
VPSRAW: 'vpsraw';
VPSRLD: 'vpsrld';
VPSRLDQ: 'vpsrldq';
VPSRLQ: 'vpsrlq';
VPSRLVD: 'vpsrlvd';
VPSRLVQ: 'vpsrlvq';
VPSRLVW: 'vpsrlvw';
VPSRLW: 'vpsrlw';
VPSUBB: 'vpsubb';
VPSUBD: 'vpsubd';
VPSUBQ: 'vpsubq';
VPSUBSB: 'vpsubsb';
VPSUBSW: 'vpsubsw';
VPSUBUSB: 'vpsubusb';
VPSUBUSW: 'vpsubusw';
VPSUBW: 'vpsubw';
VPTERNLOGD: 'vpternlogd';
VPTERNLOGQ: 'vpternlogq';
VPTEST: 'vptest';
VPTESTMB: 'vptestmb';
VPTESTMD: 'vptestmd';
VPTESTMQ: 'vptestmq';
VPTESTMW: 'vptestmw';
VPTESTNMB: 'vptestnmb';
VPTESTNMD: 'vptestnmd';
VPTESTNMQ: 'vptestnmq';
VPTESTNMW: 'vptestnmw';
VPUNPCKHBW: 'vpunpckhbw';
VPUNPCKHDQ: 'vpunpckhdq';
VPUNPCKHQDQ: 'vpunpckhqdq';
VPUNPCKHWD: 'vpunpckhwd';
VPUNPCKLBW: 'vpunpcklbw';
VPUNPCKLDQ: 'vpunpckldq';
VPUNPCKLQDQ: 'vpunpcklqdq';
VPUNPCKLWD: 'vpunpcklwd';
VPXOR: 'vpxor';
VPXORD: 'vpxord';
VPXORQ: 'vpxorq';
VRANGEPD: 'vrangepd';
VRANGEPS: 'vrangeps';
VRANGESD: 'vrangesd';
VRANGESS: 'vrangess';
VRCP14PD: 'vrcp14pd';
VRCP14PS: 'vrcp14ps';
VRCP14SD: 'vrcp14sd';
VRCP14SS: 'vrcp14ss';
VRCP28PD: 'vrcp28pd';
VRCP28PS: 'vrcp28ps';
VRCP28SD: 'vrcp28sd';
VRCP28SS: 'vrcp28ss';
VRCPPH: 'vrcpph';
VRCPPS: 'vrcpps';
VRCPSH: 'vrcpsh';
VRCPSS: 'vrcpss';
VREDUCEPD: 'vreducepd';
VREDUCEPH: 'vreduceph';
VREDUCEPS: 'vreduceps';
VREDUCESD: 'vreducesd';
VREDUCESH: 'vreducesh';
VREDUCESS: 'vreducess';
VRNDSCALEPD: 'vrndscalepd';
VRNDSCALEPS: 'vrndscaleps';
VRNDSCALESD: 'vrndscalesd';
VRNDSCALESS: 'vrndscaless';
VROUNDPD: 'vroundpd';
VROUNDPS: 'vroundps';
VROUNDSD: 'vroundsd';
VROUNDSS: 'vroundss';
VRSQRT14PD: 'vrsqrt14pd';
VRSQRT14PS: 'vrsqrt14ps';
VRSQRT14SD: 'vrsqrt14sd';
VRSQRT14SS: 'vrsqrt14ss';
VRSQRT28PD: 'vrsqrt28pd';
VRSQRT28PS: 'vrsqrt28ps';
VRSQRT28SD: 'vrsqrt28sd';
VRSQRT28SS: 'vrsqrt28ss';
VRSQRTPH: 'vrsqrtph';
VRSQRTPS: 'vrsqrtps';
VRSQRTSH: 'vrsqrtsh';
VRSQRTSS: 'vrsqrtss';
VSCALEFPD: 'vscalefpd';
VSCALEFPH: 'vscalefph';
VSCALEFPS: 'vscalefps';
VSCALEFSD: 'vscalefsd';
VSCALEFSH: 'vscalefsh';
VSCALEFSS: 'vscalefss';
VSCATTERDPD: 'vscatterdpd';
VSCATTERDPS: 'vscatterdps';
VSCATTERPF0DPD: 'vscatterpf0dpd';
VSCATTERPF0DPS: 'vscatterpf0dps';
VSCATTERPF0QPD: 'vscatterpf0qpd';
VSCATTERPF0QPS: 'vscatterpf0qps';
VSCATTERPF1DPD: 'vscatterpf1dpd';
VSCATTERPF1DPS: 'vscatterpf1dps';
VSCATTERPF1QPD: 'vscatterpf1qpd';
VSCATTERPF1QPS: 'vscatterpf1qps';
VSCATTERQPD: 'vscatterqpd';
VSCATTERQPS: 'vscatterqps';
VSHUFF32X4: 'vshuff32x4';
VSHUFF64X2: 'vshuff64x2';
VSHUFI32X4: 'vshufi32x4';
VSHUFI64X2: 'vshufi64x2';
VSHUFPD: 'vshufpd';
VSHUFPS: 'vshufps';
VSQRTPD: 'vsqrtpd';
VSQRTPH: 'vsqrtph';
VSQRTPS: 'vsqrtps';
VSQRTSD: 'vsqrtsd';
VSQRTSH: 'vsqrtsh';
VSQRTSS: 'vsqrtss';
VSTMXCSR: 'vstmxcsr';
VSUBPD: 'vsubpd';
VSUBPH: 'vsubph';
VSUBPS: 'vsubps';
VSUBSD: 'vsubsd';
VSUBSH: 'vsubsh';
VSUBSS: 'vsubss';
VTESTPD: 'vtestpd';
VTESTPS: 'vtestps';
VUCOMISD: 'vucomisd';
VUCOMISH: 'vucomish';
VUCOMISS: 'vucomiss';
VUNPCKHPD: 'vunpckhpd';
VUNPCKHPS: 'vunpckhps';
VUNPCKLPD: 'vunpcklpd';
VUNPCKLPS: 'vunpcklps';
VXORPD: 'vxorpd';
VXORPS: 'vxorps';
VZEROALL: 'vzeroall';
VZEROUPPER: 'vzeroupper';
WBNOINVD: 'wbnoinvd';
WRFSBASE: 'wrfsbase';
WRGSBASE: 'wrgsbase';
WRMSRLIST: 'wrmsrlist';
WRMSRNS: 'wrmsrns';
WRPKRU: 'wrpkru';
WRSSD: 'wrssd';
WRSSQ: 'wrssq';
WRUSSD: 'wrussd';
WRUSSQ: 'wrussq';
XABORT: 'xabort';
XBEGIN: 'xbegin';
XCRYPTCBC: 'xcryptcbc';
XCRYPTCFB: 'xcryptcfb';
XCRYPTCTR: 'xcryptctr';
XCRYPTECB: 'xcryptecb';
XCRYPTOFB: 'xcryptofb';
XEND: 'xend';
XGETBV: 'xgetbv';
XORPD: 'xorpd';
XORPS: 'xorps';
XRESLDTRK: 'xresldtrk';
XRSTOR: 'xrstor';
XRSTOR64: 'xrstor64';
XRSTORS: 'xrstors';
XRSTORS64: 'xrstors64';
XSAVE: 'xsave';
XSAVE64: 'xsave64';
XSAVEC: 'xsavec';
XSAVEC64: 'xsavec64';
XSAVEOPT: 'xsaveopt';
XSAVEOPT64: 'xsaveopt64';
XSAVES: 'xsaves';
XSAVES64: 'xsaves64';
XSETBV: 'xsetbv';
XSHA1: 'xsha1';
XSHA256: 'xsha256';
XSTORE: 'xstore';
XSUSLDTRK: 'xsusldtrk';
XTEST: 'xtest';


BITS: 'bits';
USE16: 'use16';
USE32: 'use32';
DEFAULT: 'default';
REL: 'rel';
ABS: 'abs';
BND: 'bnd';
NOBND: 'nobnd';
SECTIONS: 'sections';
SECTION: 'section';
SEGMENTS: 'segments';
SEGMENT: 'segment';
ABSOLUTE: 'absolute';
EXTERN: 'extern';
REQUIRED: 'required';
GLOBAL: 'global';
COMMON: 'common';
NEAR: 'near';
FAR: 'far';
STATIC: 'static';
CPU: 'cpu';
FLOAT_NAME: 'float';
DAZ: 'daz';
NODAZ: 'nodaz';
UP: 'up';
DOWN: 'down';
ZERO: 'zero';
WARNING: 'warning';
ORG: 'org';
ALIGN: 'align';
VSTART: 'vstart';
START: 'start';
PROGBITS: 'progbits';
NOBITS: 'nobits';
VFOLLOWS: 'vfollows';
FOLLOWS: 'follows';
MAP: 'map';
ALL: 'all';
BRIEF: 'brief';
SYMBOLS: 'symbols';
PRIVATE: 'private';
PUBLIC: 'public';
STACK: 'stack';
CLASS_: 'class';
OVERLAY: 'overlay';
FLAT: 'flat';
GROUP: 'group';
UPPERCASE: 'uppercase';
IMPORT: 'import';
EXPORT: 'export';
RESIDENT: 'resident';
NODATA: 'nodata';
PARM: 'parm';
CODE: 'code';
TEXT: 'text';
RDATA: 'rdata';
DATA: 'data';
BSS: 'bss';
INFO: 'info';
COMDAT: 'comdat';
SAFESEH: 'safeseh';
MIXED: 'mixed';
ZEROFILL: 'zerofill';
NO_DEAD_STRIP: 'no_dead_strip';
LIVE_SUPPORT: 'live_support';
STRIP_STATIC_SYMS: 'strip_static_syms';
DEBUG: 'debug';
OSABI: 'osabi';
NOTE: 'note';
PREINIT_ARRAY: 'preinit_array';
INIT_ARRAY: 'init_array';
FINI_ARRAY: 'fini_array';
TLS: 'tls';
POINTER: 'pointer';
NOALLOC: 'noalloc';
ALLOC: 'alloc';
NOEXEC: 'noexec';
EXEC: 'exec';
NOWRITE: 'nowrite';
WRITE: 'write';
WRT: 'wrt';
FUNCTION: 'function';
OBJECT: 'object';
WEAK: 'weak';
STRONG: 'strong';
INTERNAL: 'internal';
HIDDEN_: 'hidden';
PROTECTED: 'protected';
STRICT: 'strict';
TIMES: 'times';


FLOAT_NUMBER
    : [0-9][0-9_]* '.' [0-9_]* 'e'? SIGN? [0-9_]+
    | '0x1p+' [0-9]+
    ;

DECIMAL_INTEGER
    : [0-9][0-9_]* 'd'?
    | '0d' [0-9][0-9_]*
    ;

SIGN
    : PLUS | MINUS
    ;

OCT_INTEGER
    : [0-7][0-7_]* ('q' | 'o')
    | '0' [qo][0-7][0-7_]*
    ;

HEX_INTEGER
    : [0-9A-F][0-9A-F_]+ 'h'
    | '$' [0-9A-F][0-9A-F_]*
    | '0' [xh][0-9A-F][0-9A-F_]*
    ;

BIN_INTEGER
    : [01][01_]+ ('b' | 'y')
    | '0' [by][01][01_]*
    ;

STRING
    : STRING1
    | STRING2
    ;

STRING1
    : '"' ~'"'* '"'
    ;

STRING2
    : '\u0027' ~'\u0027'* '\u0027'
    ;

WARNING_NAME
    : NAME (MINUS NAME)+
    ;

NAME
    : [a-z._?][a-z0-9_$#@~.?]*
    ;

PREPROCESSOR_DIRECTIVES
    : '%' ('define' | 'xdefine' | 'ixdefine' | 'undef' | 'assign' | 'iassign' | 'defstr' | 'deftok' | 'defalias' | 'undefalias' | 'strcat' | 'strlen' | 'substr' | 'include' | 'pathsearch' | 'depend' | 'use' | 'line' | 'clear') ~[\r\n]*
      -> channel(HIDDEN)
    ;

MULTILINE_MACRO
    : '%macro' .*? '%endmacro'
      -> channel(HIDDEN)
    ;

COMMENT
    : ';' ~[\r\n]*
      -> channel(HIDDEN)
    ;

EOL
    : [\r\n] +
    ;

WHITESPACE
    : [ \t]
      -> channel(HIDDEN)
    ;

